diff --git a/.env.example b/.env.example
index efedda9..3b632bb 100644
--- a/.env.example
+++ b/.env.example
@@ -1,12 +1,10 @@
-OPENAI_API_TYPE = "Set this to "azure" for API key authentication or "azure_ad" for Azure AD authentication>"
-OPENAI_API_KEY = "<YOUR AZURE OPENAI API KEY - If using Azure AD auth, this can be left empty>"
-OPENAI_API_BASE = "<YOUR AZURE OPENAI ENDPOINT>"
-OPENAI_API_VERSION = "2023-05-15"
-OPENAI_COMPLETION_MODEL = "<YOUR OPENAI COMPLETIONS MODEL NAME - e.g. gpt-35-turbo>"
-AZURE_TENANT_ID = "<AZURE AD TENANT ID - Only used if you are using Azure AD to authentication>"
+OPENAI_API_VERSION = "2023-09-01-preview"
+AZURE_OPENAI_API_KEY = "<YOUR AZURE OPENAI API KEY - If using Azure AD auth, this can be left empty>"
+AZURE_OPENAI_ENDPOINT = "<YOUR AZURE OPENAI ENDPOINT>"
+AZURE_OPENAI_COMPLETION_MODEL = "<YOUR OPENAI COMPLETIONS MODEL NAME - e.g. gpt-35-turbo>"
 AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME = "<YOUR AZURE OPENAI COMPLETIONS DEPLOYMENT NAME - e.g. gpt-35-turbo>"
 AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME = "<YOUR AZURE OPENAI EMBEDDINGS DEPLOYMENT NAME - e.g. text-embedding-ada-002>"
-AZURE_COGNITIVE_SEARCH_SERVICE_NAME = "<YOUR AZURE COGNITIVE SEARCH SERVICE NAME - e.g. cognitive-search-service>"
-AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME = "<YOUR AZURE COGNITIVE SEARCH ENDPOINT NAME - e.g. https://cognitive-search-service.search.windows.net"
-AZURE_COGNITIVE_SEARCH_INDEX_NAME = "<YOUR AZURE COGNITIVE SEARCH INDEX NAME - e.g. cognitive-search-index>"
-AZURE_COGNITIVE_SEARCH_API_KEY = "<YOUR AZURE COGNITIVE SEARCH ADMIN API KEY - e.g. cognitive-search-admin-api-key>"
\ No newline at end of file
+AZURE_AI_SEARCH_SERVICE_NAME = "<YOUR AZURE AI SEARCH SERVICE NAME - e.g. ai-vectorstore-xyz>"
+AZURE_AI_SEARCH_ENDPOINT = "<YOUR AZURE AI SEARCH ENDPOINT NAME - e.g. https://ai-vectorstore-xyz.search.windows.net"
+AZURE_AI_SEARCH_INDEX_NAME = "<YOUR AZURE AI SEARCH INDEX NAME - e.g. ai-search-index>"
+AZURE_AI_SEARCH_API_KEY = "<YOUR AZURE AI SEARCH ADMIN API KEY - get this value from the Azure portal>"
\ No newline at end of file
diff --git a/README.md b/README.md
index b73ea44..618cca4 100644
--- a/README.md
+++ b/README.md
@@ -4,12 +4,12 @@ This repository introduces and helps organizations get started with building AI
 
 ## Workshop Agenda
 
-The objective of this workshop is to practice realistic AI orchestration scenarios towards learning how to build intelligent apps.
+The objective of this workshop is to practice realistic AI orchestration scenarios and to learn how to build intelligent apps.
 At the end of the workshop you will: 
 * Know how to use prompt engineering techniques for effective generative AI responses on OpenAI
 * Understand the implications of the usage of tokens and embeddings when interacting with an LLM
 * Have experience in leveraging AI orchestrators like Langchain/ Semantic Kernel with Azure OpenAI
-* Have evaluated different Vectorstores like Qdrant/ Azure Cognitive Search to enhance LLM responses with your data and context
+* Have evaluated different vector stores like Qdrant or Azure AI Search to enhance LLM responses with your data and context
 * Know how to turn a business scenario with data, context and user input into an intelligent application on Azure
 
 ### 🌅 Morning (9:00 – 12:15)
diff --git a/labs/00-setup/README.md b/labs/00-setup/README.md
index f0e534c..462039b 100644
--- a/labs/00-setup/README.md
+++ b/labs/00-setup/README.md
@@ -4,7 +4,7 @@ Here's a detailed walkthrough of what you need to get started with the labs.
 
 ## OpenAI Model Deployments
 
-During these labs, we'll make use of a *Completions* model and an *Embeddings* model, so you'll need access to at least one of each of these. Grant the participants access to Azure OpenAI Service service be assigning the `Cognitive Service OpenAI user`. If the participant is a `Cognitive Service OpenAI contributor`, they can create the following deployments themselves.
+During these labs, we'll make use of a *Completions* model and an *Embeddings* model, so you'll need access to at least one of each of these. Grant the participants access to Azure OpenAI Service service by assigning the `Cognitive Service OpenAI user`. If the participant is a `Cognitive Service OpenAI contributor`, they can create the following deployments themselves.
 
 **NOTE:** Please take extra care to make sure the correct version of each model is deployed.
 
diff --git a/labs/02-integrating-ai/00-PythonModules/pythonmodules.ipynb b/labs/02-integrating-ai/00-PythonModules/pythonmodules.ipynb
index bc50614..51c76db 100644
--- a/labs/02-integrating-ai/00-PythonModules/pythonmodules.ipynb
+++ b/labs/02-integrating-ai/00-PythonModules/pythonmodules.ipynb
@@ -6,7 +6,7 @@
    "source": [
     "# Python Modules\n",
     "\n",
-    "A handful of Python modules are necessary to use the labs in this repo. The module names are listed in the `requirements.txt` file which can be found in the `labs` folder.\n",
+    "A handful of Python modules are necessary to use the labs in this repo. The module names are listed in the `requirements.txt` file which can be found in the root of this repository.\n",
     "\n",
     "Run the below to install the required packages.\n",
     "\n",
@@ -55,7 +55,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/02-integrating-ai/01-AzureOpenAIAPI/azureopenaiapi.ipynb b/labs/02-integrating-ai/01-AzureOpenAIAPI/azureopenaiapi.ipynb
index f5271e9..1fa5042 100644
--- a/labs/02-integrating-ai/01-AzureOpenAIAPI/azureopenaiapi.ipynb
+++ b/labs/02-integrating-ai/01-AzureOpenAIAPI/azureopenaiapi.ipynb
@@ -31,87 +31,13 @@
     "\n",
     "# Load environment variables\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAI API Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"Found Azure OpenAI API Base Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
     "else: \n",
-    "    print(\"OpenAI API Base Endpoint not found. Have you configured the .env file?\")\n",
+    "    print(\"Azure OpenAI API Base Endpoint not found. Have you configured the .env file?\")\n",
     "    \n",
-    "API_KEY = os.getenv(\"OPENAI_API_KEY\")\n",
-    "# This version of the API is needed to properly retrieve the list of model deployments.\n",
-    "API_VERSION = \"2023-03-15-preview\"\n",
-    "RESOURCE_ENDPOINT = os.getenv(\"OPENAI_API_BASE\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next, we'll set the endpoint that we're going to call. This endpoint will return a list of available model deployments."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "url = RESOURCE_ENDPOINT + \"/openai/deployments?api-version=\" + API_VERSION\n",
-    "\n",
-    "print (url)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Above you will see the full URL that we are going to be calling."
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Get the list of available Model Deployments\n",
-    "\n",
-    "Now let's call that Azure OpenAI endpoint and see what it returns. We pass the API key in the HTTP header."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "r = requests.get(url, headers={\"api-key\": API_KEY})\n",
-    "\n",
-    "print(r.text)"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Above, there should now be a JSON formatted list of model deployments. The output will contain one or more sections similar to the following\n",
-    "\n",
-    "```\n",
-    "    {\n",
-    "      \"scale_settings\": {\n",
-    "        \"scale_type\": \"standard\"\n",
-    "      },\n",
-    "      \"model\": \"gpt-35-turbo\",\n",
-    "      \"owner\": \"organization-owner\",\n",
-    "      \"id\": \"gpt35turbo\",\n",
-    "      \"status\": \"succeeded\",\n",
-    "      \"created_at\": 1684150536,\n",
-    "      \"updated_at\": 1684150536,\n",
-    "      \"object\": \"deployment\"\n",
-    "    }\n",
-    "```\n",
-    "\n",
-    "In the output, you'll see the **Model Name** as the `model` value and the **Deployment Name** as the `id` value. We'll be using an `id` value for the next section."
+    "API_KEY = os.getenv(\"AZURE_OPENAI_API_KEY\")\n",
+    "API_VERSION = os.getenv(\"OPENAI_API_VERSION\")\n",
+    "RESOURCE_ENDPOINT = os.getenv(\"AZURE_OPENAI_ENDPOINT\")"
    ]
   },
   {
@@ -121,9 +47,7 @@
    "source": [
     "## Send a prompt to Azure OpenAI using the API\n",
     "\n",
-    "Next, let's call the Azure OpenAI API with a prompt. To do this, we'll need the `id` of our completion model deployment.\n",
-    "\n",
-    "We've already setup this value in the `.env` file, but you should see a matching value in the list that was output above."
+    "Now let's call the Azure OpenAI API with a prompt. To do this, we'll need the `id` of the Azure OpenAI deployment that contains our completion model. This should already be setup in the `.env` file."
    ]
   },
   {
@@ -132,8 +56,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Grab API Version in the .env file.\n",
-    "API_VERSION = os.getenv(\"OPENAI_API_VERSION\")\n",
     "DEPLOYMENT_ID = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")"
    ]
   },
@@ -142,7 +64,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As before, we'll construct a URL to call. This time, we'll also be creating a payload."
+    "We'll construct a URL to call so that you can see what it looks like."
    ]
   },
   {
@@ -161,9 +83,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Again, you will see the full URL that we are going to call. This URL will use the specified deployment to call the **chat completions** API.\n",
+    "You will see the full URL that we are going to call. This URL will use the specified deployment to call the **chat completions** API.\n",
     "\n",
-    "Next, we will call the Azure OpenAI API using the URL above. Just like last time, we pass the API key in the HTTP header. We also send a JSON formatted body as part of the request which contains the *prompt* that we want to use to get a response from the OpenAI model. In this case, our prompt is \"Once upon a time\", which should cause the model to complete the prompt by generating a story."
+    "Next, we will call the Azure OpenAI API using the URL above. We pass the API key in the HTTP header. We also send a JSON formatted body as part of the request which contains the *prompt* that we want to use to get a response from the OpenAI model. In this case, our prompt is \"Once upon a time\", which should cause the model to complete the prompt by generating a story."
    ]
   },
   {
@@ -182,7 +104,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As before, the result of the API call will be JSON data similar to the below example.\n",
+    "The result of the API call will be JSON data similar to the below example. Note that the response has been edited to make it easier to read.\n",
     "\n",
     "```\n",
     "{\n",
@@ -190,6 +112,12 @@
     "  \"object\": \"chat.completion\",\n",
     "  \"created\": 1694180212,\n",
     "  \"model\": \"gpt-35-turbo\",\n",
+    "  \"prompt_filter_results\": [\n",
+    "    {\n",
+    "      \"prompt_index\": 0,\n",
+    "      (content filter results removed for brevity)\n",
+    "    }\n",
+    "  ],\n",
     "  \"choices\": [\n",
     "    {\n",
     "      \"index\": 0,\n",
@@ -208,7 +136,7 @@
     "}\n",
     "```\n",
     "\n",
-    "Here's some more information about some of the data contained in that response.\n",
+    "Here's some information about some of the more interesting pieces of data contained in that response.\n",
     "\n",
     "Key | Description\n",
     "--- | ---\n",
@@ -227,7 +155,7 @@
    "source": [
     "## Summary\n",
     "\n",
-    "In this lab, we used the Azure OpenAI API directly to query information about our instance of the Azure OpenAI service and to send a prompt to an OpenAI model."
+    "In this lab, we used the Azure OpenAI API directly to send a prompt to an OpenAI model."
    ]
   },
   {
@@ -266,7 +194,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/02-integrating-ai/02-OpenAIPackages/openai.ipynb b/labs/02-integrating-ai/02-OpenAIPackages/openai.ipynb
index a77b184..1eb65c0 100644
--- a/labs/02-integrating-ai/02-OpenAIPackages/openai.ipynb
+++ b/labs/02-integrating-ai/02-OpenAIPackages/openai.ipynb
@@ -7,7 +7,7 @@
    "source": [
     "# 02 - Using the OpenAI Library\n",
     "\n",
-    "In the [first](../01-AzureOpenAIAPI/azureopenaiapi.ipynb) lab, we walked through calling the Azure OpenAI API directly to list available model deployments and submit a prompt for completion. An easier way to work with an API is to use a *Library*. A Library is a collection of packages and modules that allow reusable code to be shared with the community.\n",
+    "In the [first](../01-AzureOpenAIAPI/azureopenaiapi.ipynb) lab, we walked through calling the Azure OpenAI API directly to submit a prompt for completion. An easier way to work with an API is to use a *Library*. A Library is a collection of packages and modules that allow reusable code to be shared with the community.\n",
     "\n",
     "In this lab, we'll use the OpenAI Python library to perform the same operations as we did in the first lab."
    ]
@@ -22,7 +22,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -34,7 +34,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we'll bring in the values from our `.env` file."
+    "Next, we'll start to bring in the values from our `.env` file."
    ]
   },
   {
@@ -48,23 +48,16 @@
     "\n",
     "# Load environment variables\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAI API Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"Found Azure OpenAI API Base Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
     "else: \n",
-    "    print(\"OpenAI API Base Endpoint not found. Have you configured the .env file?\")"
+    "    print(\"Azure OpenAI API Base Endpoint not found. Have you configured the .env file?\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The OpenAI library needs some configuration parameters set to allow it to work with the OpenAI service. We'll set the following parameters.\n",
-    "\n",
-    "Parameter name | Description\n",
-    "--- | ---\n",
-    "`openai.api_type` | We set this value to indicate whether we're using the native OpenAI service, or the Azure OpenAI service\n",
-    "`openai.api_key` | This is the value for our API key\n",
-    "`openai.api_base` | This is the resource endpoint for the OpenAI service we're using\n",
-    "`openai_api_version` | This is the version of the API we are going to use"
+    "We'll create a new `AzureOpenAI` object and pass in the API key and version and the endpoint URL to be used."
    ]
   },
   {
@@ -73,30 +66,13 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "openai.api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai.api_base = os.getenv(\"OPENAI_API_BASE\")\n",
-    "# This version of the API is needed to properly retrieve the list of model deployments.\n",
-    "openai.api_version = \"2023-03-15-preview\""
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Get the list of available Model Deployments\n",
+    "from openai import AzureOpenAI\n",
     "\n",
-    "We can now call the `Deployment.list()` method of the OpenAI library."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "openai.Deployment.list()"
+    "client = AzureOpenAI(\n",
+    "    azure_endpoint = os.getenv(\"AZURE_OPENAI_API_ENDPOINT\"),\n",
+    "    api_key = os.getenv(\"AZURE_OPENAI_API_KEY\"),\n",
+    "    api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
+    ")"
    ]
   },
   {
@@ -104,33 +80,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You'll see that the result is the same JSON data that we got when we called the API directly.\n",
-    "\n",
     "## Send a prompt to Azure OpenAI using the OpenAI library\n",
     "\n",
-    "Ok, now that we have the list of deployment models, let's try to do a Completion.\n",
-    "\n",
-    "We'll use the values from our `.env` file to configure this."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Grab API Version in the .env file.\n",
-    "openai.api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
-    "COMPLETION_MODEL = os.getenv(\"OPENAI_COMPLETION_MODEL\")\n",
-    "DEPLOYMENT_ID = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "As we've configured the OpenAI Python library in the previous steps, we can go ahead and call the completions method to generate a response. We'll call the `ChatCompletion.create()` method and pass in the name of our `model`, the `deployment_id` and the `prompt` we want to use."
+    "Now that we have defined an Azure OpenAI instance, let's try a Chat Completion. We'll call the `chat.completions.create()` method. Note that for the `model` value, we actually pass in the id of our Azure OpenAI `deployment`. We'll also pass the `prompt` we want to use as the `content` of the `messages` parameter."
    ]
   },
   {
@@ -139,13 +91,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "r = openai.ChatCompletion.create(\n",
-    "    model = COMPLETION_MODEL,\n",
-    "    deployment_id = DEPLOYMENT_ID,\n",
+    "response = client.chat.completions.create(\n",
+    "    model = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"),\n",
     "    messages = [{\"role\" : \"assistant\", \"content\" : \"The one thing I love more than anything else is \"}],\n",
     ")\n",
     "\n",
-    "print(r)"
+    "print(response)"
    ]
   },
   {
@@ -153,9 +104,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Again, the response above should be the same JSON data that we got when we called the API directly, containing details of the model we called, the response that was generated and the token usage.\n",
+    "The response above should be similar JSON data to what we got when we called the API directly in the previous exercise, containing details of the model we called, the response that was generated and the token usage.\n",
     "\n",
-    "We could also just extract the generated response."
+    "We can use the structured response returned by the API to just extract the generated response text on its own."
    ]
   },
   {
@@ -164,7 +115,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(r.choices[0].message.content)"
+    "print(response.choices[0].message.content)"
    ]
   },
   {
@@ -178,7 +129,7 @@
     "\n",
     "You can find more details about the completions API in the reference documentation:\n",
     "\n",
-    "https://platform.openai.com/docs/api-reference/completions/create"
+    "https://platform.openai.com/docs/api-reference/chat/create"
    ]
   },
   {
@@ -217,7 +168,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/02-integrating-ai/03-Langchain/langchain.ipynb b/labs/02-integrating-ai/03-Langchain/langchain.ipynb
index 1af8eab..7906d25 100644
--- a/labs/02-integrating-ai/03-Langchain/langchain.ipynb
+++ b/labs/02-integrating-ai/03-Langchain/langchain.ipynb
@@ -27,7 +27,7 @@
    "outputs": [],
    "source": [
     "from langchain.llms import AzureOpenAI\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
+    "from langchain_openai import AzureChatOpenAI\n",
     "from langchain.schema import HumanMessage"
    ]
   },
@@ -50,7 +50,7 @@
     "from dotenv import load_dotenv\n",
     "\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAPI Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"Found Azure OpenAI Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
     "else: \n",
     "    print(\"No file .env found\")"
    ]
@@ -60,9 +60,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we'll configure Langchain by providing the API key and endpoint details, along with the API version information.\n",
-    "\n",
-    "As Langchain can work with multiple AI services, we need to specify that we want to work with Azure via the `openai_api_type` parameter."
+    "Next, we'll configure Langchain by providing the Azure OpenAI deployment name. Langchain will automatically retrieve details for the Azure OpenAI endpoint and version from the environment variables we've set above."
    ]
   },
   {
@@ -73,11 +71,7 @@
    "source": [
     "# Create an instance of Azure OpenAI\n",
     "llm = AzureChatOpenAI(\n",
-    "    openai_api_type = openai.api_type,\n",
-    "    openai_api_version = os.getenv(\"OPENAI_API_VERSION\"),\n",
-    "    openai_api_base = os.getenv(\"OPENAI_API_BASE\"),\n",
-    "    openai_api_key = os.getenv(\"OPENAI_API_KEY\"),\n",
-    "    deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
     ")"
    ]
   },
@@ -101,7 +95,7 @@
     "msg = HumanMessage(content=\"Explain step by step. How old is the president of USA?\")\n",
     "\n",
     "# Call the API\n",
-    "r = llm(messages=[msg])\n",
+    "r = llm.invoke([msg])\n",
     "\n",
     "# Print the response\n",
     "print(r.content)"
@@ -183,12 +177,12 @@
    "outputs": [],
    "source": [
     "# Run the chain only specifying the input variable.\n",
-    "response = chain.run({\"input\": \"raspberry pi\"})\n",
+    "response = chain.invoke({\"input\": \"raspberry pi\"})\n",
     "\n",
     "# As we are using a single input variable, you could also run the string like this:\n",
     "# response = chain.run(\"raspberry pi\")\n",
     "\n",
-    "print(response)"
+    "print(response['text'])"
    ]
   },
   {
@@ -237,7 +231,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/02-integrating-ai/04-SemanticKernel/semantickernel.ipynb b/labs/02-integrating-ai/04-SemanticKernel/semantickernel.ipynb
index 71cc9af..2dee653 100644
--- a/labs/02-integrating-ai/04-SemanticKernel/semantickernel.ipynb
+++ b/labs/02-integrating-ai/04-SemanticKernel/semantickernel.ipynb
@@ -48,8 +48,8 @@
     "\n",
     "// Load values into variables and strip quotes\n",
     "var model = envVars[\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"].Replace(\"\\\"\", \"\");\n",
-    "var azureEndpoint = envVars[\"OPENAI_API_BASE\"].Replace(\"\\\"\", \"\");\n",
-    "var apiKey = envVars[\"OPENAI_API_KEY\"].Replace(\"\\\"\", \"\");\n"
+    "var azureEndpoint = envVars[\"AZURE_OPENAI_ENDPOINT\"].Replace(\"\\\"\", \"\");\n",
+    "var apiKey = envVars[\"AZURE_OPENAI_API_KEY\"].Replace(\"\\\"\", \"\");\n"
    ]
   },
   {
@@ -76,7 +76,7 @@
    },
    "outputs": [],
    "source": [
-    "#r \"nuget: Microsoft.SemanticKernel, 0.24.230918.1-preview\""
+    "#r \"nuget: Microsoft.SemanticKernel, 1.0.1\""
    ]
   },
   {
@@ -107,10 +107,9 @@
    "source": [
     "using Microsoft.SemanticKernel;\n",
     "\n",
-    "var builder = new KernelBuilder();\n",
-    "builder.WithAzureChatCompletionService(model, azureEndpoint, apiKey);\n",
-    "\n",
-    "IKernel kernel = builder.Build();"
+    "var builder = Kernel.CreateBuilder();\n",
+    "builder.Services.AddAzureOpenAIChatCompletion(model, azureEndpoint, apiKey);\n",
+    "var kernel = builder.Build();"
    ]
   },
   {
@@ -118,7 +117,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's create a Semantic Function to perform a simple query. We start by creating a prompt template. Notice that we use a placeholder - `{{$input}}` - to represent a value that we will pass in later."
+    "Let's create a Semantic Function to perform a simple request to Azure OpenAI. In this case, the function contains a *prompt template*. The template allows us to define a prompt and add placeholders for values that we will provide later. These values could come from user input, or another function, for example."
    ]
   },
   {
@@ -137,7 +136,14 @@
    },
    "outputs": [],
    "source": [
-    "string prompt = \"What interesting things can I make with a {{$input}}?\";"
+    "var whatCanIMakeFunction = kernel.CreateFunctionFromPrompt(\n",
+    "    new PromptTemplateConfig()\n",
+    "    {\n",
+    "        Template = @\"What interesting things can I make with a {{$item}}?\",\n",
+    "        InputVariables = [\n",
+    "            new() { Name = \"item\", Description = \"An item to make something with.\", IsRequired=true }\n",
+    "        ]\n",
+    "    });\n"
    ]
   },
   {
@@ -145,34 +151,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we create a Semantic Function using our prompt and register it with the kernel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "dotnet_interactive": {
-     "language": "csharp"
-    },
-    "polyglot_notebook": {
-     "kernelName": "csharp"
-    },
-    "vscode": {
-     "languageId": "polyglot-notebook"
-    }
-   },
-   "outputs": [],
-   "source": [
-    "var whatCanIMakeFunction = kernel.CreateSemanticFunction(prompt);"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Finally, we invoke the function with a value passed in to replace our `{{$input}}` variable."
+    "`{{$item}}` represents the value we will provide later and will be replaced when we make the call to Azure OpenAI.\n",
+    "\n",
+    "Next, we'll define a value for `item` and then call the function, passing in the `item` as we do so."
    ]
   },
   {
@@ -191,7 +172,9 @@
    },
    "outputs": [],
    "source": [
-    "var response = await whatCanIMakeFunction.InvokeAsync(\"raspberry pi\");\n",
+    "string item = \"raspberry pi\";\n",
+    "\n",
+    "var response = await kernel.InvokeAsync(whatCanIMakeFunction, new () { { \"item\", item }});\n",
     "\n",
     "Console.WriteLine(response);"
    ]
@@ -201,11 +184,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The result is a long list of ideas for things we could make with a Raspberry Pi. \n",
+    "The result is a list of ideas for things we could make with a Raspberry Pi. \n",
     "\n",
-    "Now, let's look at chaining functions together. We can configure Semantic Kernel to perform multiple tasks, using the output of the first task as the `$input` for the second and so on.\n",
-    "\n",
-    "Let's improve the above query by getting a summary of the options that were generated. First, we'll create a new prompt that will generate a summary of some text."
+    "We could then use Semantic Kernel to take that list of ideas and summarize it. First, we'll create a new prompt that will generate a summary of some text."
    ]
   },
   {
@@ -224,18 +205,21 @@
    },
    "outputs": [],
    "source": [
-    "using Microsoft.SemanticKernel.Orchestration;\n",
-    "\n",
-    "string summaryPrompt = \"Summarize the following text: {{$input}}\";\n",
-    "var summaryFunction = kernel.CreateSemanticFunction(summaryPrompt);"
+    "var thingsToMakeSummary = kernel.CreateFunctionFromPrompt(\n",
+    "    new PromptTemplateConfig()\n",
+    "    {\n",
+    "        Template = @\"Summarize the following text: {{$thingsToMake}}?\",\n",
+    "        InputVariables = [\n",
+    "            new() { Name = \"thingsToMake\", Description = \"A list of things you could make.\", IsRequired=true }\n",
+    "        ]\n",
+    "    });"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With our new semantic function created, let's now run it together with the original prompt to generate ideas. The following code will initiate the `whatCanIMakeFunction` with the value `raspberry pi` and then pass the output from that function to the `summaryFunction`."
+    "Next, we can call the kernel again, this time passing in the list of ideas, the `response` from the previous call, as the value for `thingsToMake`."
    ]
   },
   {
@@ -254,12 +238,9 @@
    },
    "outputs": [],
    "source": [
-    "var context = await kernel.RunAsync(\n",
-    "    new ContextVariables(\"raspberry pi\"),\n",
-    "    whatCanIMakeFunction,\n",
-    "    summaryFunction);\n",
+    "var summary = await kernel.InvokeAsync(thingsToMakeSummary, new () { { \"thingsToMake\", response }});\n",
     "\n",
-    "Console.WriteLine(context);"
+    "Console.WriteLine(summary);"
    ]
   },
   {
diff --git a/labs/03-orchestration/01-Tokens/tokens.ipynb b/labs/03-orchestration/01-Tokens/tokens.ipynb
index 5339c30..70c96bb 100644
--- a/labs/03-orchestration/01-Tokens/tokens.ipynb
+++ b/labs/03-orchestration/01-Tokens/tokens.ipynb
@@ -120,7 +120,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you're successful, the results should be similar to the following\n",
+    "You should see results similar to the following\n",
     "\n",
     "`[b'Hello', b' world', b',', b' this', b' is', b' fun', b'!']`"
    ]
@@ -206,13 +206,15 @@
     "import os\n",
     "import openai\n",
     "from dotenv import load_dotenv\n",
+    "from openai import AzureOpenAI\n",
     "\n",
     "load_dotenv()\n",
     "\n",
-    "openai.api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai.api_base = os.getenv(\"OPENAI_API_BASE\")\n",
-    "openai.api_version = os.getenv(\"OPENAI_API_VERSION\")"
+    "client = AzureOpenAI(\n",
+    "    azure_endpoint = os.getenv(\"AZURE_OPENAI_API_ENDPOINT\"),\n",
+    "    api_key = os.getenv(\"AZURE_OPENAI_API_KEY\"),\n",
+    "    api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
+    ")"
    ]
   },
   {
@@ -220,7 +222,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "As you've seen in the Prompts section of this workshop, we can provide additional data to an AI model by including that data in the prompt. So, let's construct a prompt that asked for the highest rated movie and then provide the list of movies for the AI to work with."
+    "As you've seen in the Prompts section of this workshop, we can provide additional data to an AI model by including that data in the prompt. So, let's construct a prompt that asks for the highest rated movie and then provides the list of movies for the AI to work with."
    ]
   },
   {
@@ -233,7 +235,7 @@
     "query += \"CSV list of movies:\\n\"\n",
     "query += content\n",
     "\n",
-    "print (f\"{query[0:500]} ...[{len(query)} characters]\")"
+    "print (f\"{query[0:3000]} ...[{len(query)} characters]\")"
    ]
   },
   {
@@ -241,7 +243,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "You can see we've output the first few lines of the prompt and we've printed the overall size (in characters) of the prompt. Now, let's see what happens if we submit that query to the AI."
+    "You can see we've output the first few lines of the prompt and we've printed the overall size (in characters) of the prompt. Now, let's see what happens if we submit that query to the AI.\n",
+    "\n",
+    "**NOTE:** Don't be surprised to see an error message!"
    ]
   },
   {
@@ -250,13 +254,12 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "r = openai.ChatCompletion.create(\n",
-    "    model = os.getenv(\"OPENAI_COMPLETION_MODEL\"),\n",
-    "    deployment_id = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"),\n",
+    "response = client.chat.completions.create(\n",
+    "    model = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"),\n",
     "    messages = [{\"role\" : \"assistant\", \"content\" : query}],\n",
     ")\n",
     "\n",
-    "print (r)"
+    "print (response)"
    ]
   },
   {
@@ -267,10 +270,10 @@
     "This request will fail. At the end of the output, you should see an error message something like the following:\n",
     "\n",
     "```bash\n",
-    "InvalidRequestError: This model's maximum context length is 16385 tokens, however you requested 59265 tokens (59249 in your prompt; 16 for the completion). Please reduce your prompt; or completion length.\n",
+    "InvalidRequestError: This model's maximum context length is 16385 tokens. However, your messages resulted in 59265 tokens. Please reduce the length of the messages.\n",
     "```\n",
     "\n",
-    "You can see quite clearly from the error message that we've exceeded the model's maximum length. Its maximum is **16385** tokens, we've sent a request requiring **59265** tokens, which includes **59249** tokens for our query and **16** tokens needed for the response."
+    "You can see quite clearly from the error message that we've exceeded the model's maximum length. Its maximum is **16385** tokens, we've sent a request requiring **59265** tokens."
    ]
   },
   {
@@ -319,7 +322,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/03-orchestration/02-Embeddings/embeddings.ipynb b/labs/03-orchestration/02-Embeddings/embeddings.ipynb
index 48d4fe9..285a5e6 100644
--- a/labs/03-orchestration/02-Embeddings/embeddings.ipynb
+++ b/labs/03-orchestration/02-Embeddings/embeddings.ipynb
@@ -9,7 +9,7 @@
     "\n",
     "In this lab, we'll explore how we can bring our own data into the models used by Azure OpenAI.\n",
     "\n",
-    "We'll start as usual by defining our Azure OpenAI service API key and endpoint details, specifying the model deployment we want to use and then we'll initiate a connection to the Azure OpenAI service.\n",
+    "We'll start as usual by initiating a connection to the Azure OpenAI service.\n",
     "\n",
     "**NOTE**: As with previous labs, we'll use the values from the `.env` file in the root of this repository."
    ]
@@ -22,30 +22,19 @@
    "source": [
     "import os\n",
     "from langchain.llms import AzureOpenAI\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
+    "from langchain_openai import AzureChatOpenAI\n",
     "from langchain.schema import HumanMessage\n",
     "from dotenv import load_dotenv\n",
     "\n",
     "# Load environment variables\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAPI Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"Found Azure OpenAI Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
     "else: \n",
     "    print(\"No file .env found\")\n",
     "\n",
-    "openai_api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai_api_base = os.getenv(\"OPENAI_API_BASE\")\n",
-    "openai_api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
-    "deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
-    "embedding_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")\n",
-    "\n",
     "# Create an instance of Azure OpenAI\n",
     "llm = AzureChatOpenAI(\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    deployment_name = deployment_name,\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"),\n",
     "    temperature = 0\n",
     ")"
    ]
@@ -68,7 +57,7 @@
     "msg = HumanMessage(content=\"Tell me about the latest Ant-Man movie. When was it released? What is it about?\")\n",
     "\n",
     "# Call the AI\n",
-    "r = llm(messages=[msg])\n",
+    "r = llm.invoke([msg])\n",
     "\n",
     "# Print the response\n",
     "print(r.content)"
@@ -81,11 +70,11 @@
    "source": [
     "What do you notice about the response?\n",
     "\n",
-    "The AI thinks the latest \"Ant-Man\" movie was \"Ant-Man and the Wasp\" and it was released in July 2018. This is wrong, as there has been a more recent \"Ant-Man\" movie.\n",
+    "Depending on the model and version you are using, the AI either thinks the latest \"Ant-Man\" movie was \"Ant-Man and the Wasp\" and it was released in July 2018, or it may be aware of the movie \"Ant-Man and The Wasp: Quantumania\", but it will likely tell you this movie hasn't been released yet. So, how can we correct this information?\n",
     "\n",
     "OpenAI models are trained on a large set of data, but that happened at a specific point in time depending on the model. So, many of the models have no information about events that took place in recent months or years.\n",
     "\n",
-    "To help the AI out, we can provide additional information. This is the same process you would follow if you want the AI to work with your own company data. The AI won't know about information that isn't publically available, so if you want the AI to work with that information, then you'll need to get that information into the model.\n",
+    "To help the AI out, we can provide additional information. This is the same process you would follow if you want the AI to work with your own company data. The AI won't know about information that isn't publicly available, so if you want the AI to work with that information, then you'll need to get that information into the model.\n",
     "\n",
     "The thing is, you can't actually do that. The models are pre-trained, so the only way to get more information in is to retrain the model, which is an expensive and time consuming process.\n",
     "\n",
@@ -138,7 +127,9 @@
     "chain = load_qa_chain(llm)\n",
     "query = \"Tell me about the latest Ant Man movie. When was it released? What is it about?\"\n",
     "\n",
-    "chain.run(input_documents=documents, question=query)"
+    "result = chain.invoke({'input_documents': documents, 'question': query})\n",
+    "\n",
+    "print (result['output_text'])"
    ]
   },
   {
@@ -146,7 +137,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Great! The model now knows about the latest Ant-Man movie.\n",
+    "Great! The model now knows the correct details for the latest Ant-Man movie.\n",
     "\n",
     "However, there's something lurking! Let's take a look at what happened behind the scenes.\n",
     "\n",
@@ -168,7 +159,7 @@
     "\n",
     "# Run the chain, using the callback to capture the number of tokens used\n",
     "with get_openai_callback() as callback:\n",
-    "    chain.run(input_documents=documents, question=query)\n",
+    "    chain.invoke({'input_documents': documents, 'question': query})\n",
     "    total_tokens = callback.total_tokens\n",
     "\n",
     "print(f\"Total tokens used: {total_tokens}\")"
@@ -179,11 +170,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the output from the last code section, you should see a lot of information. At the end, you should see a count of the number of tokens used. You might be surprised to see that the query uses something like 2,500 tokens! That's a lot of tokens.\n",
+    "In the output from the last code section, you should see a lot of information. At the end, you should see a count of the number of tokens used. You might be surprised to see that the query uses around 2,500 tokens. That's a lot of tokens!\n",
     "\n",
     "With the verbose option enabled, the rest of the output shows the prompt that was constructed for the query. If you scroll back through the output, you'll see that the prompt included **all** of the information from our documents, so this is why the query used so many tokens.\n",
     "\n",
-    "As we've discussed previously, AI models have a maximum number of tokens you can use and a charging model based on the number of tokens consumed. In this example, the documents are relatively small in size and there's only 20 of them, so clearly this is not going to scale when we want to work with larger documents and more of them."
+    "As we've discussed previously, AI models have a maximum number of tokens you can use and a charging model based on the number of tokens consumed. In this example, the documents are relatively small in size and there's only 20 of them, but if we wanted to work with larger documents and more of them, then this method would quickly become expensive and eventually we'd hit the token limit."
    ]
   },
   {
@@ -203,7 +194,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Let's walk through the process of using embeddings to give the AI some details about our movies. We'll start by initiating an instance of an embeddings model. You'll notice this is similar to when we initialise one of our model deployments to run a query, but in this case we specify and embedding model. Typically the embedding model used is `text-embedding-ada-002`."
+    "Let's walk through the process of using embeddings to give the AI some details about our movies. We'll start by initiating an instance of an embeddings model. You'll notice this is similar to when we initialise one of our model deployments to run a query, but in this case we specify an embedding model. Typically the embedding model used is `text-embedding-ada-002`."
    ]
   },
   {
@@ -212,15 +203,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.embeddings import OpenAIEmbeddings\n",
+    "from langchain_openai import AzureOpenAIEmbeddings\n",
     "\n",
-    "embeddings_model = OpenAIEmbeddings(\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    deployment = embedding_name,\n",
-    "    chunk_size = 1\n",
+    "embeddings_model = AzureOpenAIEmbeddings(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME\")\n",
     ")"
    ]
   },
@@ -229,8 +215,6 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**NOTE:** The `chunk_size = 1` parameter is used to workaround a temporary limitation in the Azure OpenAI API which only allows one embedding to be processed at a time with each call to the API.\n",
-    "\n",
     "Now that we've initialised a model to create embeddings, let's go ahead and embed some documents.\n",
     "\n",
     "As we did in the previous example, we'll use Langchain's builit in loaders to read the documents from a directory."
@@ -312,7 +296,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we define a `RetrievalQA` chain. This chain brings handles the process of answering a question by performing the search on the vector store, then taking the results of that search and passing them to our AI model."
+    "Next we define a `RetrievalQA` chain. This handles the process of answering a question by performing the search on the vector store, then taking the results of that search and passing them to our AI model."
    ]
   },
   {
@@ -344,7 +328,8 @@
    "outputs": [],
    "source": [
     "query = \"Tell me about the latest MCU movie. When was it released? What is it about?\"\n",
-    "qa.run(query)"
+    "result = qa.invoke(query)\n",
+    "print(result['result'])"
    ]
   },
   {
@@ -364,7 +349,7 @@
    "outputs": [],
    "source": [
     "with get_openai_callback() as callback:\n",
-    "    qa.run(query)\n",
+    "    qa.invoke(query)\n",
     "    total_tokens = callback.total_tokens\n",
     "\n",
     "print(f\"Total tokens used: {total_tokens}\")"
@@ -453,11 +438,11 @@
     "\n",
     "📣 [Qdrant with Langchain](../03-Qdrant/qdrant.ipynb)\n",
     "\n",
-    "📣 [Azure Cognitive Search with Semantic Kernel and C#](../04-ACS/acs-sk-csharp.ipynb)\n",
+    "📣 [Azure AI Search with Semantic Kernel and C#](../04-ACS/acs-sk-csharp.ipynb)\n",
     "\n",
-    "📣 [Azure Cognitive Search with Semantic Kernel and Python](../04-ACS/acs-sk-python.ipynb)\n",
+    "📣 [Azure AI Search with Semantic Kernel and Python](../04-ACS/acs-sk-python.ipynb)\n",
     "\n",
-    "📣 [Azure Cognitive Search with Langchain and Python](../04-ACS/acs-lc-python.ipynb)"
+    "📣 [Azure AI Search with Langchain and Python](../04-ACS/acs-lc-python.ipynb)"
    ]
   }
  ],
@@ -477,7 +462,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.6"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/03-orchestration/03-Qdrant/qdrant.ipynb b/labs/03-orchestration/03-Qdrant/qdrant.ipynb
index b85f5c4..9ad4163 100644
--- a/labs/03-orchestration/03-Qdrant/qdrant.ipynb
+++ b/labs/03-orchestration/03-Qdrant/qdrant.ipynb
@@ -7,11 +7,9 @@
    "source": [
     "# 03 - Langchain with Qdrant\n",
     "\n",
-    "In this lab, we will do a deeper dive around the Qdrant vector store and different ways to interact with it.\n",
+    "In this lab, we will do a deeper dive around the Qdrant vector store and different ways to interact with it. We'll look at how we can use different search methods to vary the results and how we can use the results with a large language model.\n",
     "\n",
-    "We'll start as usual by defining our Azure OpenAI service API key and endpoint details, specifying the model deployment we want to use and then we'll initiate a connection to the Azure OpenAI service.\n",
-    "\n",
-    "**NOTE**: As with previous labs, we'll use the values from the `.env` file in the root of this repository."
+    "We'll start as usual by loading the values from the `.env` file in the root of this repository."
    ]
   },
   {
@@ -25,17 +23,9 @@
     "\n",
     "# Load environment variables\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAPI Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"Found Azure OpenAI Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
     "else: \n",
-    "    print(\"No file .env found\")\n",
-    "\n",
-    "openai_api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai_api_base = os.getenv(\"OPENAI_API_BASE\")\n",
-    "openai_api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
-    "deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
-    "completion_model = os.getenv(\"OPENAI_COMPLETION_MODEL\")\n",
-    "embedding_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")"
+    "    print(\"No file .env found\")"
    ]
   },
   {
@@ -43,7 +33,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First, we will load the data from the movies.csv file using a Langchain document loader."
+    "In this lab, we'll use the data from the movies.csv file in this folder, which contains details of around 500 different movies. We'll use a Langchain document loader to load all of the movie data into memory."
    ]
   },
   {
@@ -56,7 +46,7 @@
     "\n",
     "loader = CSVLoader(file_path='./movies.csv', source_column='original_title', encoding='utf-8', csv_args={'delimiter':',', 'fieldnames': ['id', 'original_language', 'original_title', 'popularity', 'release_date', 'vote_average', 'vote_count', 'genre', 'overview', 'revenue', 'runtime', 'tagline']})\n",
     "data = loader.load()\n",
-    "data = data[1:11] # reduce dataset if you want\n",
+    "# data = data[1:51] # You can uncomment this line to load a smaller subset of the data if you experience issues with token limits or timeouts later in this lab.\n",
     "print('Loaded %s movies' % len(data))"
    ]
   },
@@ -65,7 +55,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we will create an Azure OpenAI embedding and completion deployments in order to create the vector representation of the movies in the loaded CSV file and then be able to ask questions."
+    "Next, we'll create Azure OpenAI embedding and chat completion deployments. The embeddings instance will be used to create the vector representation of the movies in the loaded CSV file and the chat completion instance will be used to ask questions."
    ]
   },
   {
@@ -74,24 +64,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.embeddings import OpenAIEmbeddings\n",
-    "from langchain.llms import AzureOpenAI\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
+    "from langchain_openai import AzureChatOpenAI\n",
+    "from langchain_openai import AzureOpenAIEmbeddings\n",
     "\n",
     "# Create an Embeddings Instance of Azure OpenAI\n",
-    "embeddings = OpenAIEmbeddings(\n",
-    "    deployment=embedding_name,\n",
-    "    chunk_size=1\n",
-    ") \n",
+    "embeddings = AzureOpenAIEmbeddings(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME\")\n",
+    ")\n",
     "\n",
     "# Create a Chat Completion Instance of Azure OpenAI\n",
     "llm = AzureChatOpenAI(\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    deployment_name = deployment_name,\n",
-    "    model_name=completion_model\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
     ")"
    ]
   },
@@ -104,9 +87,11 @@
     "\n",
     "**NOTE**: Please read the following carefully.\n",
     "\n",
-    "If you are running the lab in Codespaces or a VS Code local devcontainer, Qdrant is already running, continue to the next section.\n",
+    "In previous labs, we ran the Qdrant vector store in memory, so it's contents were lost once Qdrant stopped running. In this lab, we'll run Qdrant to persist data to disk.\n",
     "\n",
-    "Otherwise, we need to start Qdrant and the easiest way is using Docker."
+    "If you are running this lab in Codespaces or a VS Code local devcontainer, then Qdrant is already running and you can continue to the next section.\n",
+    "\n",
+    "Otherwise, we need to start a local instance of Qdrant. The easiest way to do this is with Docker. If you don't have Docker on your device, consider running this workshop in a Codespace or a VS Code devcontainer."
    ]
   },
   {
@@ -130,9 +115,9 @@
    "source": [
     "## Load Movies into Qdrant\n",
     "\n",
-    "Now that we have the Qdrant server running and persisting data locally, **see the qdrantstorage directory for more details**, let's load the movies into the vector store.\n",
+    "Now that we have the Qdrant server running and persisting data locally, let's load the movies into the vector store.\n",
     "\n",
-    "We'll configure Langchain to use Qdrant as vector store, embedd the loaded documents and store the embeddings in the vector store.\n",
+    "We'll configure Langchain to use Qdrant as the vector store, embed the loaded documents and store the embeddings in the vector store.\n",
     "\n",
     "**NOTE**: Depending on the number of movies loaded and rate limiting, this might take a while."
    ]
@@ -155,6 +140,13 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**NOTE:** After this has run, you can, if you  wish, browse the structure of the persisted data. You should see a `qdrantstorage` folder in the same location as this lab."
+   ]
+  },
   {
    "attachments": {},
    "cell_type": "markdown",
@@ -162,9 +154,9 @@
    "source": [
     "## Vector Store Searching using Qdrant\n",
     "\n",
-    "Now we are going to test the vector store by searching it in different ways.\n",
+    "Now we are going to demonstrate how the results of searching a vector store can be affected by using different search methods.\n",
     "\n",
-    "The first way is to search for similarity."
+    "The most common method used is a similarity search. This search method aims to return the most similar documents to the query text, using a metric such as cosine similarity."
    ]
   },
   {
@@ -175,10 +167,12 @@
    "source": [
     "vectorstore = qdrant\n",
     "\n",
-    "query = \"What is the best 80s movie I should look at?\"\n",
-    "found_docs = vectorstore.similarity_search(query)\n",
+    "query = \"Can you suggest similar movies to The Matrix?\"\n",
+    "\n",
+    "query_results = qdrant.similarity_search(query)\n",
     "\n",
-    "print(found_docs[0].metadata['source'])"
+    "for doc in query_results:\n",
+    "    print(doc.metadata['source'])"
    ]
   },
   {
@@ -186,7 +180,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Another way would be to search for similar movies but with more diverse results, note the **mmr** search_type."
+    "Another commonly used method is MMR - Maximal Marginal Relevance - which also executes a similarity search, but the algorithm is geared towards returning a more diverse set of results."
    ]
   },
   {
@@ -197,8 +191,17 @@
    "source": [
     "retriever = vectorstore.as_retriever(search_type=\"mmr\")\n",
     "\n",
-    "query = \"Which movies are about space travel?\"\n",
-    "print(retriever.get_relevant_documents(query)[0].metadata['source'])"
+    "query = \"Can you suggest similar movies to The Matrix?\"\n",
+    "\n",
+    "for doc in retriever.get_relevant_documents(query):\n",
+    "    print(doc.metadata['source'])\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In both of the above examples, a list of movies will have been returned. Both should be relevant to the query, but the MMR search should return a more diverse set of results. To explain that a little more, the first set of results might, for example, all be from the same genre, whereas the MMR search would return results from a wider range of genres."
    ]
   },
   {
@@ -207,7 +210,9 @@
    "source": [
     "## Vector Store Searching using Langchain Retriever\n",
     "\n",
-    "In this part we will use Langchain to search the Qdrant vector store and retrieve the results. This is different than the previous section where we were using Qdrant's search API directly."
+    "In this part we will use Langchain to search the Qdrant vector store and parse the results via a large language model. This is different from the previous section where we were simply returning the results of a Qdrant search directly.\n",
+    "\n",
+    "As you will have seen in the **02-Embeddings** lab, we can use the `VectorstoreIndexCreator` to quickly create a vector store index and a retriever.\n"
    ]
   },
   {
@@ -228,7 +233,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we are using a Langchain QA chain to ask questions about the movies."
+    "Now we can use a Langchain QA (Question Answering) retrieval chain to ask questions about the movies."
    ]
   },
   {
@@ -237,29 +242,64 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "llm = AzureChatOpenAI(\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    deployment_name = deployment_name,\n",
-    "    model_name = completion_model\n",
-    ")\n",
     "chain = RetrievalQA.from_chain_type(llm=llm, chain_type=\"stuff\", retriever=docsearch.vectorstore.as_retriever(), input_key=\"question\", return_source_documents=True)\n",
     "\n",
     "query = \"Do you have a column called popularity?\"\n",
-    "print (\"First query: \" + query)\n",
-    "response = chain({\"question\": query})\n",
-    "print(response['result'])\n",
-    "print (\"Source documents for first query\")\n",
-    "print(response['source_documents'])\n",
-    "print (\"\\n\")\n",
+    "response = chain.invoke({\"question\": query})\n",
+    "print(response['result'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "You can see that we've retrieved a set of search results from the vector store, and then used the LLM to parse the results and provide a natural language answer to the question.\n",
     "\n",
-    "query = \"What is the movie with the highest popularity?\"\n",
-    "print (\"Second query: \" + query)\n",
-    "response = chain({\"question\": query})\n",
-    "print(response['result'])\n",
-    "print(\"Source Documents for second query\")\n",
+    "We can also see the documents that were retrieved from the search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(response['source_documents'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We could ask a different question, such as \"What is the name of the most popular movie?\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"If the popularity score is defined as a higher value being a more popular movie, what is the name of the most popular movie in the data provided?\"\n",
+    "response = chain.invoke({\"question\": query})\n",
+    "print(response['result'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Again, you'll see that instead of just returning the search result, we've got a natural language answer to the question.\n",
+    "\n",
+    "And we can see the set of documents that were retrieved, which will be different to those returned for the previous question because we asked a different question."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "print(response['source_documents'])"
    ]
   },
@@ -269,11 +309,11 @@
    "source": [
     "## Next Section\n",
     "\n",
-    "📣 [ACS with LC and Python](../04-ACS/acs-lc-python.ipynb)\n",
+    "📣 [Azure AI Search with Semantic Kernel and C#](../04-ACS/acs-sk-csharp.ipynb)\n",
     "\n",
-    "📣 [ACS with SK and C#](../04-ACS/acs-sk-csharp.ipynb)\n",
+    "📣 [Azure AI Search with Semantic Kernel and Python](../04-ACS/acs-sk-python.ipynb)\n",
     "\n",
-    "📣 [ACS with SK and Python](../04-ACS/acs-sk-python.ipynb)"
+    "📣 [Azure AI Search with Langchain and Python](../04-ACS/acs-lc-python.ipynb)"
    ]
   }
  ],
@@ -293,7 +333,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.6"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/03-orchestration/04-ACS/acs-lc-python.ipynb b/labs/03-orchestration/04-ACS/acs-lc-python.ipynb
index edeffe5..5695c0e 100644
--- a/labs/03-orchestration/04-ACS/acs-lc-python.ipynb
+++ b/labs/03-orchestration/04-ACS/acs-lc-python.ipynb
@@ -5,20 +5,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 04 - AI Orchestration with Azure Cognitive Search\n",
+    "# 04 - AI Orchestration with Azure AI Search\n",
+    "**(Langchain / Python version)**\n",
     "\n",
-    "In this lab, we will do a deeper dive around the Azure Cognitive Search vector store and different ways to interact with it."
+    "In this lab, we will do a deeper dive into using Azure AI Search as a vector store, the different search methods it supports and how you can use it as part of the Retrieval Augmented Generation (RAG) pattern for working with large language models."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Create Azure Cognitive Search Vector Store in Azure\n",
+    "## Create an Azure AI Search Vector Store in Azure\n",
     "\n",
-    "First, we need to create an Azure Cognitive Search service in Azure, which will act as a vector store. We'll use the Azure CLI to do this.\n",
+    "First, we will create an Azure AI Search service in Azure. The following are command line instructions and require the Azure CLI to be installed.\n",
     "\n",
-    "**NOTE:** Update **`<INITIALS>`** to make the name unique."
+    "**NOTE:** Before running the commands, replace the **`<INITIALS>`** with your own initials or some random characters, as we need to provide a unique name for the Azure AI Search service."
    ]
   },
   {
@@ -27,9 +28,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "RESOURCE_GROUP=\"azure-cognitive-search-rg\"\n",
+    "RESOURCE_GROUP=\"azure-ai-search-rg\"\n",
     "LOCATION=\"westeurope\"\n",
-    "NAME=\"acs-vectorstore-<INITIALS>\"\n",
+    "NAME=\"ai-vectorstore-<INITIALS>\"\n",
     "!az group create --name $RESOURCE_GROUP --location $LOCATION\n",
     "!az search service create -g $RESOURCE_GROUP -n $NAME -l $LOCATION --sku Basic --partition-count 1 --replica-count 1"
    ]
@@ -38,13 +39,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we need to find and update the following values in the `.env` file with the Azure Cognitive Search **endpoint**, **admin key**, and **index name** values. Use the Azure Portal or CLI.\n",
+    "Next, we need to find and update the following values in the `.env` file with the Azure AI Search **name**, **endpoint** and **admin key** values, which you can get from the Azure portal. You also need to provide an **index name** value. The index will be created during this lab, so you can use any name you like.\n",
     "\n",
     "```\n",
-    "AZURE_COGNITIVE_SEARCH_SERVICE_NAME = \"<YOUR AZURE COGNITIVE SEARCH SERVICE NAME - e.g. cognitive-search-service>\"\n",
-    "AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME = \"<YOUR AZURE COGNITIVE SEARCH ENDPOINT NAME - e.g. https://cognitive-search-service.search.windows.net\"\n",
-    "AZURE_COGNITIVE_SEARCH_INDEX_NAME = \"<YOUR AZURE COGNITIVE SEARCH INDEX NAME - e.g. cognitive-search-index>\"\n",
-    "AZURE_COGNITIVE_SEARCH_API_KEY = \"<YOUR AZURE COGNITIVE SEARCH ADMIN API KEY - e.g. cognitive-search-admin-api-key>\"\n",
+    "AZURE_AI_SEARCH_SERVICE_NAME = \"<YOUR AZURE AI SEARCH SERVICE NAME - e.g. ai-vectorstore-xyz>\"\n",
+    "AZURE_AI_SEARCH_ENDPOINT = \"<YOUR AZURE AI SEARCH ENDPOINT URL - e.g. https://ai-vectorstore-xyz.search.windows.net\"\n",
+    "AZURE_AI_SEARCH_INDEX_NAME = \"<YOUR AZURE AI SEARCH INDEX NAME - e.g. ai-search-index>\"\n",
+    "AZURE_AI_SEARCH_API_KEY = \"<YOUR AZURE AI SEARCH ADMIN API KEY - e.g. get this value from the Azure portal>\"\n",
     "```"
    ]
   },
@@ -52,11 +53,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Setup Azure OpenAI\n",
-    "\n",
-    "We'll start as usual by defining our Azure OpenAI service API key and endpoint details, specifying the model deployment we want to use and then we'll initiate a connection to the Azure OpenAI service.\n",
-    "\n",
-    "**NOTE**: As with previous labs, we'll use the values from the `.env` file in the root of this repository."
+    "## Load environment variable values\n",
+    "As with previous labs, we'll use the values from the `.env` file in the root of this repository."
    ]
   },
   {
@@ -70,20 +68,21 @@
     "\n",
     "# Load environment variables\n",
     "if load_dotenv():\n",
-    "    print(\"Found OpenAPI Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
+    "    print(\"This lab exercise will use the following values:\")\n",
+    "    print(\"Azure OpenAI Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
+    "    print(\"Azure AI Search: \" + os.getenv(\"AZURE_AI_SEARCH_SERVICE_NAME\"))\n",
     "else: \n",
     "    print(\"No file .env found\")\n",
     "\n",
-    "openai_api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai_api_base = os.getenv(\"OPENAI_API_BASE\")\n",
+    "azure_openai_api_key = os.getenv(\"AZURE_OPENAI_API_KEY\")\n",
+    "azure_openai_endpoint = os.getenv(\"AZURE_OPENAI_ENDPOINT\")\n",
     "openai_api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
-    "deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
-    "embedding_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")\n",
-    "acs_service_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_SERVICE_NAME\")\n",
-    "acs_endpoint_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME\")\n",
-    "acs_index_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_INDEX_NAME\")\n",
-    "acs_api_key = os.getenv(\"AZURE_COGNITIVE_SEARCH_API_KEY\")"
+    "azure_openai_completion_deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
+    "azure_openai_embedding_deployment_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")\n",
+    "azure_ai_search_name = os.getenv(\"AZURE_AI_SEARCH_SERVICE_NAME\")\n",
+    "azure_ai_search_endpoint = os.getenv(\"AZURE_AI_SEARCH_ENDPOINT\")\n",
+    "azure_ai_search_index_name = os.getenv(\"AZURE_AI_SEARCH_INDEX_NAME\")\n",
+    "azure_ai_search_api_key = os.getenv(\"AZURE_AI_SEARCH_API_KEY\")"
    ]
   },
   {
@@ -91,7 +90,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First, we will load the data from the movies.csv file using the Langchain CSV document loader."
+    "First, we will load the data from the movies.csv file and then extract a subset to load into the Azure AI Search index. We do this to help avoid the Azure OpenAI embedding limits and long loading times when inserting data into the index. We use a Langchain document loader to do this."
    ]
   },
   {
@@ -102,12 +101,15 @@
    "source": [
     "from langchain.document_loaders.csv_loader import CSVLoader\n",
     "\n",
-    "# Movie Fields in CSV\n",
-    "# id,original_language,original_title,popularity,release_date,vote_average,vote_count,genre,overview,revenue,runtime,tagline\n",
     "loader = CSVLoader(file_path='./movies.csv', source_column='original_title', encoding='utf-8', csv_args={'delimiter':',', 'fieldnames': ['id', 'original_language', 'original_title', 'popularity', 'release_date', 'vote_average', 'vote_count', 'genre', 'overview', 'revenue', 'runtime', 'tagline']})\n",
     "data = loader.load()\n",
-    "data = data[1:51] # reduce dataset if you want\n",
-    "print('Loaded %s movies' % len(data))"
+    "\n",
+    "# Rather than load all 500 movies into Azure AI search, we will use a\n",
+    "# smaller subset of movie data to make things quicker. The more movies you load,\n",
+    "# the more time it will take for embeddings to be generated.\n",
+    "\n",
+    "data = data[1:51]\n",
+    "print('Loaded %s movies.' % len(data))"
    ]
   },
   {
@@ -115,7 +117,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we will create an Azure OpenAI embedding and completion deployments in order to create the vector representation of the movies so we can start asking our questions."
+    "During this lab, we will need to work with embeddings. We use embeddings to create a vector representation of a piece of text. We will need to create embeddings for the documents we want to store in our Azure AI Search index and also for the queries we want to use to search the index. We will create an Azure OpenAI client to do this."
    ]
   },
   {
@@ -124,45 +126,20 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
-    "\n",
-    "# Create an Embeddings Instance of Azure OpenAI\n",
-    "embeddings = OpenAIEmbeddings(\n",
-    "    model=\"text-embedding-ada-002\",\n",
-    "    deployment=embedding_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    embedding_ctx_length=8191,\n",
-    "    chunk_size=1000,\n",
-    "    max_retries=6\n",
-    ")\n",
+    "from langchain_openai import AzureOpenAIEmbeddings\n",
     "\n",
-    "# Create a Completion Instance of Azure OpenAI\n",
-    "llm = AzureChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo\",\n",
-    "    deployment_name = deployment_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    temperature=0.7,\n",
-    "    max_retries=6,\n",
-    "    max_tokens=4000\n",
-    ")\n",
-    "\n",
-    "print('Completed creation of embedding and completion instances.')"
+    "azure_openai_embeddings = AzureOpenAIEmbeddings(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME\")\n",
+    ")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Load Movies into Azure Cognitive Search\n",
+    "## Create an Azure AI Search index and load movie data\n",
     "\n",
-    "Next, we'll create the Azure Cognitive Search index, embed the loaded movies from the CSV file, and upload the data into the newly created index. Depending on the number of movies loaded and rate limiting, this might take a while to do the embeddings so be patient."
+    "Next, we'll step through the process of configuring an Azure AI Search index to store our movie data and then loading the data into the index. "
    ]
   },
   {
@@ -172,84 +149,139 @@
    "outputs": [],
    "source": [
     "from azure.core.credentials import AzureKeyCredential\n",
+    "from azure.search.documents import SearchClient\n",
     "from azure.search.documents.indexes import SearchIndexClient\n",
     "from azure.search.documents.indexes.models import (\n",
-    "    SearchIndex,\n",
-    "    SearchField,\n",
-    "    SearchFieldDataType,\n",
+    "    VectorSearch,\n",
+    "    VectorSearchProfile,\n",
+    "    HnswAlgorithmConfiguration,\n",
+    "    SemanticPrioritizedFields,\n",
+    "    SemanticSearch,\n",
+    "    SemanticField,\n",
+    "    SemanticConfiguration,\n",
     "    SimpleField,\n",
     "    SearchableField,\n",
-    "    SearchIndex,\n",
-    "    SemanticConfiguration,\n",
-    "    PrioritizedFields,\n",
-    "    SemanticField,\n",
     "    SearchField,\n",
-    "    SemanticSettings,\n",
-    "    VectorSearch,\n",
-    "    HnswVectorSearchAlgorithmConfiguration,\n",
+    "    SearchFieldDataType,\n",
+    "    SearchIndex\n",
     ")\n",
+    "from azure.search.documents.models import (\n",
+    "    VectorizedQuery\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When configuring an Azure AI Search index, we need to specify the fields we want to store in the index and the data types for each field. These match the fields in the movie data, containing values such as the movie title, genre, year of release and so on.\n",
     "\n",
-    "# Let's Create the Azure Cognitive Search Index\n",
-    "index_client = SearchIndexClient(\n",
-    "    acs_endpoint_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "# Movie Fields in CSV\n",
-    "# id,original_language,original_title,popularity,release_date,vote_average,vote_count,genre,overview,revenue,runtime,tagline\n",
+    "To use Azure AI Search as a vector store, we will also need to define a field to hold the vector representaion of the movie data. We indicate to Azure AI Search that this field will contain vector data by providing details of the vector dimensions and a profile. We'll also define the vector search configuration and profile with default values.\n",
+    "\n",
+    "**NOTE:** It is possible just to use Azure AI Search as a vector store only, in which case we probably wouldn't need to define all of the index fields below. However, in this lab, we're also going to demonstrate Hybrid Search, a feature which makes use of both traditional keyword based search in combination with vector search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "fields = [\n",
     "    SimpleField(name=\"id\", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True),\n",
     "    SearchableField(name=\"title\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"overview\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"genre\", type=SearchFieldDataType.String),\n",
     "    SearchableField(name=\"tagline\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"release_date\", type=SearchFieldDataType.DateTimeOffset, sortable=True),\n",
     "    SearchableField(name=\"popularity\", type=SearchFieldDataType.Double, sortable=True),\n",
-    "    SearchableField(name=\"content\", type=SearchFieldDataType.String),\n",
-    "    SearchField(name=\"content_vector\", type=SearchFieldDataType.Collection(SearchFieldDataType.Single), searchable=True, vector_search_dimensions=1536, vector_search_configuration=\"my-vector-config\"),\n",
+    "    SearchableField(name=\"vote_average\", type=SearchFieldDataType.Double, sortable=True),\n",
+    "    SearchableField(name=\"vote_count\", type=SearchFieldDataType.Int32, sortable=True),\n",
+    "    SearchableField(name=\"runtime\", type=SearchFieldDataType.Int32, sortable=True),\n",
+    "    SearchableField(name=\"revenue\", type=SearchFieldDataType.Int64, sortable=True),\n",
+    "    SearchableField(name=\"original_language\", type=SearchFieldDataType.String),\n",
+    "    SearchField(name=\"vector\", type=SearchFieldDataType.Collection(SearchFieldDataType.Single), searchable=True, vector_search_dimensions=1536, vector_search_profile_name=\"movies-vector-profile\"),\n",
     "]\n",
     "\n",
-    "# Configure Vector Search Configuration\n",
     "vector_search = VectorSearch(\n",
-    "    algorithm_configurations=[\n",
-    "        HnswVectorSearchAlgorithmConfiguration(\n",
-    "            name=\"my-vector-config\",\n",
-    "            kind=\"hnsw\",\n",
-    "            parameters={\n",
-    "                \"m\": 4,\n",
-    "                \"efConstruction\": 400,\n",
-    "                \"efSearch\": 500,\n",
-    "                \"metric\": \"cosine\"\n",
-    "            }\n",
-    "        )\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "# Configure Semantic Configuration\n",
+    "    profiles=[VectorSearchProfile(name=\"movies-vector-profile\", algorithm_configuration_name=\"movies-vector-config\")],\n",
+    "    algorithms=[HnswAlgorithmConfiguration(name=\"movies-vector-config\")],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We're going to be using Semantic Ranking, a feature of Azure AI Search that improves search results by using language understanding to rerank the search results. We provide a Semantic Search Configuration to help the ranking model understand the movie data, by telling it which fields contain the movie title, which fields contain keywords and which fields contain general free text content."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "semantic_config = SemanticConfiguration(\n",
-    "    name=\"my-semantic-config\",\n",
-    "    prioritized_fields=PrioritizedFields(\n",
+    "    name=\"movies-semantic-config\",\n",
+    "    prioritized_fields=SemanticPrioritizedFields(\n",
     "        title_field=SemanticField(field_name=\"title\"),\n",
-    "        prioritized_keywords_fields=[SemanticField(field_name=\"title\"), SemanticField(field_name=\"tagline\")],\n",
-    "        prioritized_content_fields=[SemanticField(field_name=\"content\")]\n",
+    "        keywords_fields=[SemanticField(field_name=\"genre\")],\n",
+    "        content_fields=[SemanticField(field_name=\"title\"),\n",
+    "                        SemanticField(field_name=\"overview\"),\n",
+    "                        SemanticField(field_name=\"tagline\"),\n",
+    "                        SemanticField(field_name=\"genre\"),\n",
+    "                        SemanticField(field_name=\"release_date\"),\n",
+    "                        SemanticField(field_name=\"popularity\"),\n",
+    "                        SemanticField(field_name=\"vote_average\"),\n",
+    "                        SemanticField(field_name=\"vote_count\"),\n",
+    "                        SemanticField(field_name=\"runtime\"),\n",
+    "                        SemanticField(field_name=\"revenue\"),\n",
+    "                        SemanticField(field_name=\"original_language\")],\n",
     "    )\n",
     ")\n",
     "\n",
-    "# Create the semantic settings with the configuration\n",
-    "semantic_settings = SemanticSettings(configurations=[semantic_config])\n",
-    "\n",
+    "semantic_search = SemanticSearch(configurations=[semantic_config])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we'll go ahead and create the index by creating an instance of the `SearchIndex` class and adding the keyword and vectors fields and the semantic search profile."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "# Create the search index with the desired vector search and semantic configurations\n",
     "index = SearchIndex(\n",
-    "    name=acs_index_name,\n",
+    "    name=azure_ai_search_index_name,\n",
     "    fields=fields,\n",
     "    vector_search=vector_search,\n",
-    "    semantic_settings=semantic_settings\n",
+    "    semantic_search=semantic_search\n",
     ")\n",
+    "\n",
+    "index_client = SearchIndexClient(\n",
+    "    azure_ai_search_endpoint,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
+    ")\n",
+    "\n",
     "result = index_client.create_or_update_index(index)\n",
-    "print(f'The {result.name} index was created.')"
+    "\n",
+    "print(f'Index {result.name} created.')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we will create the document structure needed to upload the data into the Azure Cognitive Search index."
+    "The index is now ready, so next we need to prepare the movie data to load into the index.\n",
+    "\n",
+    "**NOTE**: During this phase, we send the data for each movie to an Azure OpenAI embeddings model to create the vector data. This may take some time due to rate limiting in the API."
    ]
   },
   {
@@ -258,32 +290,51 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Now that the index is created, let's load the documents into it.\n",
-    "\n",
-    "import uuid\n",
+    "# Loop through all of the movies and create a new item for each one.\n",
     "\n",
-    "# Let's take a quick look at the data structure of the CSVLoader\n",
-    "print(data[0])\n",
-    "print(data[0].metadata['source'])\n",
-    "print(\"----------\")\n",
-    "\n",
-    "# Generate Document Embeddings for page_content field in the movies CSVLoader dataset using Azure OpenAI\n",
     "items = []\n",
     "for movie in data:\n",
     "    content = movie.page_content\n",
-    "    items.append(dict([(\"id\", str(uuid.uuid4())), (\"title\", movie.metadata['source']), (\"content\", content), (\"content_vector\", embeddings.embed_query(content))]))\n",
-    "\n",
-    "# Print out a sample item to validate the updated data structure.\n",
-    "# It should have the id, content, and content_vector values.\n",
-    "print(items[0])\n",
-    "print(f\"Movie Count: {len(items)}\")"
+    "    fields = movie.page_content.split('\\n')\n",
+    "    movieId = (fields[0].split(': ')[1])[:-2]\n",
+    "    movieTitle = (fields[2].split(': ')[1])\n",
+    "    movieOverview = (fields[8].split(': ')[1])\n",
+    "    movieGenre = (fields[7].split(': ')[1])[1:-1]\n",
+    "    movieTagline = (fields[11].split(': ')[1])\n",
+    "    movieReleaseDate = (fields[4].split(': ')[1])\n",
+    "    moviePopularity = (fields[3].split(': ')[1])\n",
+    "    movieVoteAverage = (fields[5].split(': ')[1])\n",
+    "    movieVoteCount = (fields[6].split(': ')[1])\n",
+    "    movieRuntime = (fields[10].split(': ')[1])\n",
+    "    movieRevenue = (fields[9].split(': ')[1])\n",
+    "    movieOriginalLanguage = (fields[1].split(': ')[1])\n",
+    "\n",
+    "    items.append(dict([\n",
+    "        (\"id\", movieId), \n",
+    "        (\"title\", movieTitle),\n",
+    "        (\"overview\", movieOverview),\n",
+    "        (\"genre\", movieGenre),\n",
+    "        (\"tagline\", movieTagline),\n",
+    "        (\"release_date\", movieReleaseDate),\n",
+    "        (\"popularity\", moviePopularity),\n",
+    "        (\"vote_average\", movieVoteAverage),\n",
+    "        (\"vote_count\", movieVoteCount),\n",
+    "        (\"runtime\", movieRuntime),\n",
+    "        (\"revenue\", movieRevenue),\n",
+    "        (\"original_language\", movieOriginalLanguage),\n",
+    "        (\"vector\", azure_openai_embeddings.embed_query(content))\n",
+    "    ]))\n",
+    "\n",
+    "    print(f\"Movie {movieTitle} added.\")\n",
+    "\n",
+    "print(f\"New items structure with embeddings created for {len(items)} movies.\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we will upload the movie documents in the newly created structure to the Azure Cognitive Search index."
+    "We can write out the contents of one of the documents to see what it looks like. You can see that it contains the movie data at the top and then a long array containing the vector data."
    ]
   },
   {
@@ -292,28 +343,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Upload movies to Azure Cognitive Search index.\n",
-    "from azure.search.documents.models import Vector\n",
-    "from azure.search.documents import SearchClient\n",
-    "\n",
-    "# Insert Text and Embeddings into the Azure Cognitive Search index created.\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "result = search_client.upload_documents(items)\n",
-    "print(\"Successfully added documents to Azure Cognitive Search index.\")\n",
-    "print(f\"Uploaded {len(data)} documents\")"
+    "print(items[0])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Vector Store Searching using Azure Cognitive Search\n",
-    "\n",
-    "Now that we have the movies loaded into Azure Cognitive Search, let's do some different types of searches using the Azure Cognitive Search SDK."
+    "Now we have the movie data stored in the correct format, so let's load it into the Azure AI Search index we created earlier."
    ]
   },
   {
@@ -322,30 +359,28 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# First, let's do a plain vanilla text search, no vectors or embeddings.\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
+    "from azure.search.documents import SearchClient\n",
     "\n",
     "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
+    "    azure_ai_search_endpoint,\n",
+    "    azure_ai_search_index_name,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
     ")\n",
     "\n",
-    "# Execute the search\n",
-    "results = list(search_client.search(\n",
-    "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=5\n",
-    "))\n",
+    "result = search_client.upload_documents(items)\n",
     "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using only text-based search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over Results\n",
-    "# Index Fields - id, content, content_vector\n",
-    "for result in results:\n",
-    "    print(\"Movie: {}\".format(result[\"content\"]))\n",
-    "    print(\"----------\")"
+    "print(f\"Successfully loaded {len(data)} movies into Azure AI Search index.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vector store searching using Azure AI Search\n",
+    "\n",
+    "We've loaded the movies into Azure AI Search, so now let's experiment with some of the different types of searches you can perform.\n",
+    "\n",
+    "First we'll just perform a simple keyword search."
    ]
   },
   {
@@ -354,36 +389,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Now let's do a vector search that uses the embeddings we created and inserted into content_vector field in the index.\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
+    "query = \"hero\"\n",
     "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
     "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
+    "    search_text=query,\n",
+    "    query_type=\"simple\",\n",
     "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\", \"title\"],\n",
+    "    top=5\n",
     "))\n",
     "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using only vector-based search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the content.\n",
     "for result in results:\n",
-    "    print(result[\"title\"])\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
     "    print(\"----------\")"
    ]
   },
@@ -391,9 +408,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Did that return what you expected? Probably not, let's dig deeper to see why.\n",
+    "We get some results, but they're not necessarily movies about heroes. It could be that there is some text in the index for these results that relates to the word \"hero\". For example, the description might mention \"heroic deeds\" or something similar.\n",
     "\n",
-    "Let's do the same search again, but this time let's return the **Search Score** so we can see the value returned by the cosine similarity vector store calculation."
+    "Let's now try the same again, but this time we'll ask a question instead of just searching for a keyword."
    ]
   },
   {
@@ -402,38 +419,18 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Try again, but this time let's add the relevance score to maybe see why\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
+    "query = \"What are the best movies about superheroes?\"\n",
     "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
     "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
+    "    search_text=query,\n",
+    "    query_type=\"simple\",\n",
     "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\", \"title\"],\n",
+    "    top=5\n",
     "))\n",
     "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Id: {result['title']}\")\n",
-    "    print(f\"Score: {result['@search.score']}\")\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
     "    print(\"----------\")"
    ]
   },
@@ -441,7 +438,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you look at the Search Score you will see the relevant ranking of the closest vector match to the query inputted. The lower the score the farther apart the two vectors are. Let's change the search term and see if we can get a higher Search Score which means a higher match and closer vector proximity."
+    "As before, you will likely get mixed results. Some of the movies returned could be about heroes, but others may not be. This is because the search is still based on keywords.\n",
+    "\n",
+    "Next, let's try a vector search."
    ]
   },
   {
@@ -450,38 +449,24 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Try again, but this time let's add the relevance score to maybe see why\n",
-    "query = \"Who are the actors in the movie Hidden Figures?\"\n",
+    "query = \"What are the best movies about superheroes?\"\n",
     "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
+    "vector = VectorizedQuery(vector=azure_openai_embeddings.embed_query(query), k_nearest_neighbors=5, fields=\"vector\")\n",
     "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
+    "# Note the `None` value for the `search_text` parameter. This is because we're not sending the query text to Azure AI Search. We're sending the embedded version of the query text instead via the `vector_queries` parameter.\n",
     "\n",
-    "# Execute the search\n",
     "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
-    "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\", \"title\"],\n",
+    "    search_text=None,\n",
+    "    query_type=\"semantic\",\n",
+    "    semantic_configuration_name=\"movies-semantic-config\",\n",
+    "    vector_queries=[vector],\n",
+    "    select=[\"title\", \"genre\"],\n",
+    "    top=5\n",
     "))\n",
     "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Id: {result['title']}\")\n",
-    "    print(f\"Score: {result['@search.score']}\")\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
     "    print(\"----------\")"
    ]
   },
@@ -489,18 +474,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**NOTE:** As you have seen from the results, different inputs can return different results, it all depends on what data is in the Vector Store. The higher the score the higher the likelihood of a match."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Hybrid Searching using Azure Cognitive Search\n",
+    "It's likely that the raw vector search didn't return exactly what you were expecting. You were probably expecting a list of superhero movies, but now we're getting a list of movies that are **similar** to the vector we provided. Some of these may be hero movies, but others may not be. The vector search is returning the nearest neighbours to the vector we provided, so it's possible that at least one of the results is a superhero movie, and the others are similar to that movie in some way.\n",
+    "\n",
+    "So, both the keyword search and the vector search have their limitations. The keyword search is limited to the keywords in the index, so it's possible that we might miss some movies that are about heroes. The vector search is limited to returning the nearest neighbours to the vector we provide, so it's possible that we might get some movies that are not about heroes.\n",
+    "\n",
+    "## Hybrid search using Azure AI Search\n",
     "\n",
-    "What is Hybrid Search? The search is implemented at the field level, which means you can build queries that include vector fields and searchable text fields. The queries execute in parallel and the results are merged into a single response. Optionally, add semantic search, currently in preview, for even more accuracy with L2 reranking using the same language models that power Bing.\n",
+    "To overcome the limitations of both keyword search and vector search, we can use a combination of both. This is known as Hybrid Search. Let's run the same query again, but this time we'll use Hybrid Search.\n",
     "\n",
-    "**NOTE:** Hybrid Search is a key value proposition of Azure Cognitive Search in comparison to vector only data stores. Click [Hybrid Search](https://learn.microsoft.com/en-us/azure/search/hybrid-search-overview) for more details."
+    "The only significant difference is that this time we will submit both the original query text and the embedding vector to Azure AI Search. Azure AI Search will then use both the query text and the vector to perform the search and combine the results."
    ]
   },
   {
@@ -509,86 +491,36 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Hybrid Search\n",
-    "# Let's try our original query again using Hybrid Search (ie. Combination of Text & Vector Search)\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
+    "query = \"What are the best movies about superheroes?\"\n",
     "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
+    "vector = VectorizedQuery(vector=azure_openai_embeddings.embed_query(query), k_nearest_neighbors=5, fields=\"vector\")\n",
     "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
+    "# Note the `None` value for the `search_text` parameter. This is because we're not sending the query text to Azure AI Search. We're sending the embedded version of the query text instead via the `vector_queries` parameter.\n",
     "\n",
-    "# Notice we also fill in the search_text parameter with the query.\n",
     "results = list(search_client.search(\n",
     "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=10,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\", \"title\"],\n",
+    "    query_type=\"semantic\",\n",
+    "    semantic_configuration_name=\"movies-semantic-config\",\n",
+    "    vector_queries=[vector],\n",
+    "    select=[\"title\", \"genre\"],\n",
+    "    top=5\n",
     "))\n",
     "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(result['title'])\n",
-    "    print(f\"Hybrid Search Score: {result['@search.score']}\")\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
+    "    print(\"Score: {}\".format(result[\"@search.score\"]))\n",
+    "    print(\"Reranked score: {}\".format(result[\"@search.reranker_score\"]))\n",
     "    print(\"----------\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "# Hybrid Search\n",
-    "# Let's try our more specific query again to see the difference in the score returned.\n",
-    "query = \"Who are the actors in the movie Hidden Figures?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
+    "Hopefully, you'll now see a much better set of results. Performing a hybrid search has allowed us to combine the benefits of both keyword search and vector search. But also, Azure AI Search performs a further step when using hybrid search. It makes use of a Semantic Ranker to further improve the search results. The Semantic Ranker uses a language understanding model to understand the query text and the documents in the index and then uses this information to rerank the search results. So, after performing the keyword and vector search, Azure AI Search will then use the Semantic Ranker to re-order the search results based on the context of the original query.\n",
     "\n",
-    "# -----\n",
-    "# Notice we also fill in the search_text parameter with the query along with the vector.\n",
-    "# -----\n",
-    "results = list(search_client.search(\n",
-    "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=10,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\", \"title\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using hybrid search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Title: {result['title']}\")\n",
-    "    print(f\"Hybrid Search Score: {result['@search.score']}\")\n",
-    "    print(\"----------\")"
+    "In the results above, you can see a `Reranked Score`. This is the score that has been calculated by the Semantic Ranker. The `Score` is the score calculated by the keyword and vector search. You'll note that the results are returned in the order determined by the reranked score."
    ]
   },
   {
@@ -601,7 +533,7 @@
     "1. Ask the question\n",
     "2. Create Prompt Template with inputs\n",
     "3. Get Embedding representation of inputted question\n",
-    "4. Use embedded version of the question to search Azure Cognitive Search (ie. The Vector Store)\n",
+    "4. Use embedded version of the question to search Azure AI Search (ie. The Vector Store)\n",
     "5. Inject the results of the search into the Prompt Template & Execute the Prompt to get the completion"
    ]
   },
@@ -613,39 +545,21 @@
    "source": [
     "# Implement RAG using Langchain (LC)\n",
     "\n",
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
+    "from langchain_openai import AzureOpenAIEmbeddings\n",
+    "from langchain_openai import AzureChatOpenAI\n",
     "from langchain.chains import LLMChain\n",
     "\n",
-    "# Setup Langchain\n",
-    "# Create an Embeddings Instance of Azure OpenAI\n",
-    "embeddings = OpenAIEmbeddings(\n",
-    "    model=\"text-embedding-ada-002\",\n",
-    "    deployment=embedding_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    embedding_ctx_length=8191,\n",
-    "    chunk_size=1000,\n",
-    "    max_retries=6\n",
+    "\n",
+    "azure_openai_embeddings = AzureOpenAIEmbeddings(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME\")\n",
     ")\n",
     "\n",
-    "# Create a Completion Instance of Azure OpenAI\n",
-    "llm = AzureChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo\",\n",
-    "    deployment_name = deployment_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    temperature=0.7,\n",
-    "    max_retries=6,\n",
-    "    max_tokens=4000\n",
+    "azure_openai = AzureChatOpenAI(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
     ")\n",
     "\n",
     "# Ask the question\n",
-    "question = \"List the movies about ships on the water.\"\n",
+    "query = \"What are the best movies about superheroes?\"\n",
     "\n",
     "# Create a prompt template with variables, note the curly braces\n",
     "from langchain.prompts import PromptTemplate\n",
@@ -656,35 +570,34 @@
     "\n",
     "    Do not use any other data.\n",
     "    Only use the movie data below when responding.\n",
+    "    Provide detailed information about the synopsis of the movie.\n",
     "    {search_results}\n",
     "    \"\"\",\n",
     ")\n",
     "\n",
-    "# Get Embedding for the original question\n",
-    "question_embedded=embeddings.embed_query(question)\n",
-    "\n",
     "# Search Vector Store\n",
     "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "vector = Vector(\n",
-    "    value=question_embedded,\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
+    "    azure_ai_search_endpoint,\n",
+    "    azure_ai_search_index_name,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
     ")\n",
+    "\n",
+    "vector = VectorizedQuery(vector=azure_openai_embeddings.embed_query(query), k_nearest_neighbors=5, fields=\"vector\")\n",
+    "\n",
     "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
+    "    search_text=query,\n",
+    "    query_type=\"semantic\",\n",
+    "    semantic_configuration_name=\"movies-semantic-config\",\n",
     "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"title\"],\n",
+    "    vector_queries=[vector],\n",
+    "    select=[\"title\",\"genre\",\"overview\",\"tagline\",\"release_date\",\"popularity\",\"vote_average\",\"vote_count\",\"runtime\",\"revenue\",\"original_language\"],\n",
+    "    top=5\n",
     "))\n",
     "\n",
     "# Build the Prompt and Execute against the Azure OpenAI to get the completion\n",
-    "chain = LLMChain(llm=llm, prompt=prompt, verbose=True)\n",
-    "response = chain.run({\"original_question\": question, \"search_results\": results})\n",
-    "print(response)"
+    "chain = LLMChain(llm=azure_openai, prompt=prompt, verbose=False)\n",
+    "response = chain.invoke({\"original_question\": query, \"search_results\": results})\n",
+    "print(response['text'])"
    ]
   },
   {
@@ -713,7 +626,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.6"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/03-orchestration/04-ACS/acs-sk-csharp.ipynb b/labs/03-orchestration/04-ACS/acs-sk-csharp.ipynb
index a17abfd..5d34d0c 100644
--- a/labs/03-orchestration/04-ACS/acs-sk-csharp.ipynb
+++ b/labs/03-orchestration/04-ACS/acs-sk-csharp.ipynb
@@ -5,20 +5,21 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# 04 - AI Orchestration with Azure Cognitive Search\n",
+    "# 04 - AI Orchestration with Azure AI Search\n",
+    "**(Semantic Kernel / C# version)**\n",
     "\n",
-    "In this lab, we will do a deeper dive around the Azure Cognitive Search vector store and different ways to interact with it."
+    "In this lab, we will do a deeper dive into using Azure AI Search as a vector store, the different search methods it supports and how you can use it as part of the Retrieval Augmented Generation (RAG) pattern for working with large language models."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Create Azure Cognitive Search Vector Store in Azure\n",
+    "## Create an Azure AI Search Vector Store in Azure\n",
     "\n",
-    "First, we need to create an Azure Cognitive Search service in Azure, which will act as a vector store. We'll use the Azure CLI to do this.\n",
+    "First, we will create an Azure AI Search service in Azure. We'll use the Azure CLI to do this, so you'll need to cut and paste the following commands into a terminal window.\n",
     "\n",
-    "**NOTE:** Update **`<INITIALS>`** to make the name unique."
+    "**NOTE:** Before running the commands, replace the **`<INITIALS>`** with your own initials or some random characters, as we need to provide a unique name for the Azure AI Search service."
    ]
   },
   {
@@ -37,10 +38,11 @@
    },
    "outputs": [],
    "source": [
-    "// Execute the following commands using the Azure CLI to create the Azure Cognitive Search resource in Azure.\n",
-    "RESOURCE_GROUP=\"azure-cognitive-search-rg\"\n",
+    "// Execute the following commands using the Azure CLI to create the Azure AI Search resource in Azure.\n",
+    "\n",
+    "RESOURCE_GROUP=\"azure-ai-search-rg\"\n",
     "LOCATION=\"westeurope\"\n",
-    "NAME=\"acs-vectorstore-<INITIALS>\"\n",
+    "NAME=\"ai-vectorstore-<INITIALS>\"\n",
     "az group create --name $RESOURCE_GROUP --location $LOCATION\n",
     "az search service create -g $RESOURCE_GROUP -n $NAME -l $LOCATION --sku Basic --partition-count 1 --replica-count 1"
    ]
@@ -49,13 +51,13 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we need to find and update the following values in the `.env` file with the Azure Cognitive Search **endpoint**, **admin key**, and **index name** values. Use the Azure Portal or CLI.\n",
+    "Next, we need to find and update the following values in the `.env` file with the Azure AI Search **name**, **endpoint** and **admin key** values, which you can get from the Azure portal. You also need to provide an **index name** value. The index will be created during this lab, so you can use any name you like.\n",
     "\n",
     "```\n",
-    "AZURE_COGNITIVE_SEARCH_SERVICE_NAME = \"<YOUR AZURE COGNITIVE SEARCH SERVICE NAME - e.g. cognitive-search-service>\"\n",
-    "AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME = \"<YOUR AZURE COGNITIVE SEARCH ENDPOINT NAME - e.g. https://cognitive-search-service.search.windows.net\"\n",
-    "AZURE_COGNITIVE_SEARCH_INDEX_NAME = \"<YOUR AZURE COGNITIVE SEARCH INDEX NAME - e.g. cognitive-search-index>\"\n",
-    "AZURE_COGNITIVE_SEARCH_API_KEY = \"<YOUR AZURE COGNITIVE SEARCH ADMIN API KEY - e.g. cognitive-search-admin-api-key>\"\n",
+    "AZURE_AI_SEARCH_SERVICE_NAME = \"<YOUR AZURE AI SEARCH SERVICE NAME - e.g. ai-vectorstore-xyz>\"\n",
+    "AZURE_AI_SEARCH_ENDPOINT = \"<YOUR AZURE AI SEARCH ENDPOINT URL - e.g. https://ai-vectorstore-xyz.search.windows.net\"\n",
+    "AZURE_AI_SEARCH_INDEX_NAME = \"<YOUR AZURE AI SEARCH INDEX NAME - e.g. ai-search-index>\"\n",
+    "AZURE_AI_SEARCH_API_KEY = \"<YOUR AZURE AI SEARCH ADMIN API KEY - e.g. get this value from the Azure portal>\"\n",
     "```"
    ]
   },
@@ -63,11 +65,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Setup Azure OpenAI\n",
-    "\n",
-    "We'll start as usual by defining our Azure OpenAI service API key and endpoint details, specifying the model deployment we want to use and then we'll initiate a connection to the Azure OpenAI service.\n",
+    "## Load the required .NET packages\n",
     "\n",
-    "**NOTE**: As with previous labs, we'll use the values from the `.env` file in the root of this repository."
+    "This lab uses C#, so we will need to load the required .NET packages."
    ]
   },
   {
@@ -87,30 +87,60 @@
    "outputs": [],
    "source": [
     "// Add the Packages\n",
-    "#r \"nuget: DotNetEnv, 2.5.0\"\n",
-    "#r \"nuget: Microsoft.SemanticKernel, 0.24.230918.1-preview\"\n",
-    "#r \"nuget: Azure.AI.OpenAI, 1.0.0-beta.7\"\n",
-    "#r \"nuget: Azure.Identity, 1.10.1\"\n",
-    "#r \"nuget: Azure.Search.Documents, 11.5.0-beta.4\"\n",
-    "\n",
+    "#r \"nuget: dotenv.net, 3.1.2\"\n",
+    "#r \"nuget: Azure.AI.OpenAI, 1.0.0-beta.12\"\n",
+    "#r \"nuget: Azure.Identity, 1.10.4\"\n",
+    "#r \"nuget: Azure.Search.Documents, 11.5.0-beta.5\""
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load environment variable values\n",
+    "As with previous labs, we'll use the values from the `.env` file in the root of this repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
     "using System.IO;\n",
+    "using dotenv.net;\n",
     "\n",
     "// Read values from .env file\n",
-    "DotNetEnv.Env.Load(\"../../../.env\");\n",
-    "\n",
-    "// Load values into variables\n",
-    "var openai_api_type = System.Environment.GetEnvironmentVariable(\"OPENAI_API_TYPE\");\n",
-    "var openai_api_key = System.Environment.GetEnvironmentVariable(\"OPENAI_API_KEY\");\n",
-    "var openai_api_base = System.Environment.GetEnvironmentVariable(\"OPENAI_API_BASE\");\n",
-    "var openai_api_version = System.Environment.GetEnvironmentVariable(\"OPENAI_API_VERSION\");\n",
-    "var deployment_name = System.Environment.GetEnvironmentVariable(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\");\n",
-    "var embedding_name = System.Environment.GetEnvironmentVariable(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\");\n",
-    "var acs_service_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_SERVICE_NAME\");\n",
-    "var acs_endpoint_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME\");\n",
-    "var acs_index_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_INDEX_NAME\");\n",
-    "var acs_api_key = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_API_KEY\");\n",
-    "\n",
-    "Console.WriteLine(\"Environment Variables loaded.\");"
+    "var envVars = DotEnv.Fluent()\n",
+    "    .WithoutExceptions()\n",
+    "    .WithEnvFiles(\"../../../.env\")\n",
+    "    .WithTrimValues()\n",
+    "    .WithDefaultEncoding()\n",
+    "    .WithOverwriteExistingVars()\n",
+    "    .WithoutProbeForEnv()\n",
+    "    .Read();\n",
+    "\n",
+    "var azure_openai_api_key = envVars[\"AZURE_OPENAI_API_KEY\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_openai_endpoint = envVars[\"AZURE_OPENAI_ENDPOINT\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_openai_embedding_deployment_name = envVars[\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_name = envVars[\"AZURE_AI_SEARCH_SERVICE_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_endpoint = envVars[\"AZURE_AI_SEARCH_ENDPOINT\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_api_key = envVars[\"AZURE_AI_SEARCH_API_KEY\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_index_name = envVars[\"AZURE_AI_SEARCH_INDEX_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "\n",
+    "Console.WriteLine(\"This lab exercise will use the following values:\");\n",
+    "Console.WriteLine($\"Azure OpenAI Endpoint: {azure_openai_endpoint}\");\n",
+    "Console.WriteLine($\"Azure AI Search: {azure_ai_search_name}\");"
    ]
   },
   {
@@ -118,7 +148,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "First, we will load the data from the movies.csv file and then extract a subset to load into the Azure Cognitive Search index. We do this to help avoid the Azure OpenAI embedding limits and long loading times when inserting data into the index."
+    "First, we will load the data from the movies.csv file and then extract a subset to load into the Azure AI Search index. We do this to help avoid the Azure OpenAI embedding limits and long loading times when inserting data into the index."
    ]
   },
   {
@@ -139,13 +169,14 @@
    "source": [
     "using System.IO;\n",
     "\n",
-    "// Movie Fields in CSV\n",
-    "// id,original_language,original_title,popularity,release_date,vote_average,vote_count,genre,overview,revenue,runtime,tagline\n",
     "string path = @\"./movies.csv\";\n",
     "string[] allMovies;\n",
     "string[] movieSubset;\n",
-    "// The subset of movies to load into the Azure Cognitive Search Index.\n",
-    "// The more movies you load, the longer it will take due to Embedding limits.\n",
+    "//\n",
+    "// Rather than load all 500 movies into Azure AI search, we will use a\n",
+    "// smaller subset of movie data to make things quicker. The more movies you load,\n",
+    "// the more time it will take for embeddings to be generated.\n",
+    "//\n",
     "int movieSubsetCount = 50;\n",
     "try\n",
     "{\n",
@@ -161,7 +192,7 @@
     "}\n",
     "\n",
     "// Write out the results.\n",
-    "Console.WriteLine($\"CSV File Loaded {movieSubset.Length}.\");"
+    "Console.WriteLine($\"Loaded {movieSubset.Length} movies.\");"
    ]
   },
   {
@@ -169,7 +200,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next, we will create an Azure OpenAI Client to do embeddings and completions."
+    "During this lab, we will need to work with embeddings. We use embeddings to create a vector representation of a piece of text. We will need to create embeddings for the documents we want to store in our Azure AI Search index and also for the queries we want to use to search the index. We will create an Azure OpenAI client to do this."
    ]
   },
   {
@@ -192,19 +223,16 @@
     "using Azure.AI.OpenAI;\n",
     "using Azure.Identity;\n",
     "\n",
-    "// Create the Azure OpenAI client.\n",
-    "OpenAIClient azureOpenAIClient = new OpenAIClient(new Uri(openai_api_base),new AzureKeyCredential(openai_api_key));\n",
-    "\n",
-    "Console.WriteLine(\"Azure OpenAI client Created.\");"
+    "OpenAIClient azureOpenAIClient = new OpenAIClient(new Uri(azure_openai_endpoint),new AzureKeyCredential(azure_openai_api_key));"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Load Movies into Azure Cognitive Search\n",
+    "## Create an Azure AI Search index and load movie data\n",
     "\n",
-    "Next, we'll create the Azure Cognitive Search index, embed the loaded movies from the CSV file, and upload the data into the newly created index. Depending on the number of movies loaded and rate limiting, this might take a while to do the embeddings so be patient."
+    "Next, we'll step through the process of configuring an Azure AI Search index to store our movie data and then loading the data into the index. "
    ]
   },
   {
@@ -229,57 +257,179 @@
     "using Azure.Search.Documents.Indexes.Models;\n",
     "using Microsoft.Extensions.Configuration;\n",
     "\n",
-    "// Setup variables.\n",
-    "string vectorSearchConfigName = \"my-vector-config\";\n",
-    "string semanticSearchConfigName = \"my-semantic-config\";\n",
-    "int modelDimensions = 1536;\n",
+    "// These variables store the names of Azure AI Search profiles and configs that we will use\n",
     "\n",
-    "// Create an Azure Cognitive Search index client.\n",
-    "AzureKeyCredential indexCredential = new AzureKeyCredential(acs_api_key);\n",
-    "SearchIndexClient indexClient = new SearchIndexClient(new Uri(acs_endpoint_name), indexCredential);\n",
+    "string vectorSearchHnswProfile = \"movies-vector-profile\";\n",
+    "string vectorSearchHnswConfig = \"movies-vector-config\";\n",
+    "string semanticSearchConfigName = \"movies-semantic-config\";\n",
     "\n",
-    "// Create the index definition.\n",
-    "// Setup the VectorSearch configuration.\n",
-    "VectorSearch vectorSearch = new VectorSearch();\n",
-    "vectorSearch.AlgorithmConfigurations.Add(new HnswVectorSearchAlgorithmConfiguration(vectorSearchConfigName));\n",
-    "// Setup the SemanticSettings configuration.\n",
-    "SemanticSettings semanticSettings = new SemanticSettings();\n",
-    "semanticSettings.Configurations.Add(new SemanticConfiguration(semanticSearchConfigName, new PrioritizedFields()\n",
-    "{\n",
-    "    TitleField = new SemanticField() { FieldName = \"content\" },\n",
-    "    KeywordFields = { new SemanticField() { FieldName = \"content\" } },\n",
-    "    ContentFields = { new SemanticField() { FieldName = \"content\" } },\n",
-    "}));\n",
-    "// Setup the Fields configuration.\n",
+    "// The OpenAI embeddings model has 1,536 dimensions\n",
+    "\n",
+    "int modelDimensions = 1536;"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When configuring an Azure AI Search index, we need to specify the fields we want to store in the index and the data types for each field. These match the fields in the movie data, containing values such as the movie title, genre, year of release and so on.\n",
+    "\n",
+    "**NOTE:** It is possible just to use Azure AI Search as a vector store only, in which case we probably wouldn't need to define all of the index fields below. However, in this lab, we're also going to demonstrate Hybrid Search, a feature which makes use of both traditional keyword based search in combination with vector search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
     "IList<SearchField> fields = new List<SearchField>();\n",
-    "fields.Add(new SimpleField(\"id\", SearchFieldDataType.String) { IsKey = true, IsFilterable = true, IsSortable = true, IsFacetable = true });\n",
-    "fields.Add(new SearchableField(\"content\", false) {});\n",
-    "fields.Add(new SearchField(\"content_vector\", SearchFieldDataType.Collection(SearchFieldDataType.Single))\n",
+    "fields.Add(new SimpleField(\"id\", SearchFieldDataType.String) { IsKey = true, IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"title\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"overview\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"genre\", false) { IsFilterable = true, IsSortable = true, IsFacetable = true });\n",
+    "fields.Add(new SearchableField(\"tagline\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"release_date\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"popularity\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"vote_average\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"vote_count\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"runtime\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"revenue\", false) { IsFilterable = true, IsSortable = true });\n",
+    "fields.Add(new SearchableField(\"original_language\", false) { IsFilterable = true, IsSortable = true });"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To use Azure AI Search as a vector store, we will need to define a field to hold the vector representaion of the movie data. We indicate to Azure AI Search that this field will contain vector data by providing details of the vector dimensions and a profile. We'll also define the vector search configuration and profile with default values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "fields.Add(new SearchField(\"vector\", SearchFieldDataType.Collection(SearchFieldDataType.Single))\n",
     "{\n",
     "    IsSearchable = true,\n",
     "    VectorSearchDimensions = modelDimensions,\n",
-    "    VectorSearchConfiguration = vectorSearchConfigName\n",
+    "    VectorSearchProfile = vectorSearchHnswProfile,\n",
     "});\n",
     "\n",
+    "VectorSearch vectorSearch = new VectorSearch();\n",
+    "vectorSearch.Algorithms.Add(new HnswVectorSearchAlgorithmConfiguration(vectorSearchHnswConfig));\n",
+    "vectorSearch.Profiles.Add(new VectorSearchProfile(vectorSearchHnswProfile, vectorSearchHnswConfig));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We're going to be using Semantic Ranking, a feature of Azure AI Search that improves search results by using language understanding to rerank the search results. We configure Semantic Settings to help the ranking model understand the movie data, by telling it which fields contain the movie title, which fields contain keywords and which fields contain general free text content."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "SemanticSettings semanticSettings = new SemanticSettings();\n",
+    "semanticSettings.Configurations.Add(new SemanticConfiguration(semanticSearchConfigName, new PrioritizedFields()\n",
+    "{\n",
+    "    TitleField = new SemanticField() { FieldName = \"title\" },\n",
+    "    KeywordFields = { new SemanticField() { FieldName = \"genre\" } },\n",
+    "    ContentFields = { new SemanticField() { FieldName = \"title\" },\n",
+    "                      new SemanticField() { FieldName = \"overview\" },\n",
+    "                      new SemanticField() { FieldName = \"tagline\" },\n",
+    "                      new SemanticField() { FieldName = \"genre\" },\n",
+    "                      new SemanticField() { FieldName = \"release_date\" },\n",
+    "                      new SemanticField() { FieldName = \"popularity\" },\n",
+    "                      new SemanticField() { FieldName = \"vote_average\" },\n",
+    "                      new SemanticField() { FieldName = \"vote_count\" },\n",
+    "                      new SemanticField() { FieldName = \"runtime\" },\n",
+    "                      new SemanticField() { FieldName = \"revenue\" },\n",
+    "                      new SemanticField() { FieldName = \"original_language\" }\n",
+    "    }\n",
+    "}));"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we'll go ahead and create the index by creating an instance of the `SearchIndex` class and adding the keyword and vectors fields and the semantic search profile."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
     "// Setup SearchIndex\n",
-    "SearchIndex searchIndex = new SearchIndex(acs_index_name);\n",
+    "SearchIndex searchIndex = new SearchIndex(azure_ai_search_index_name);\n",
     "searchIndex.VectorSearch = vectorSearch;\n",
     "searchIndex.SemanticSettings = semanticSettings;\n",
     "searchIndex.Fields = fields;\n",
     "\n",
-    "// Create the index\n",
+    "// Create an Azure AI Search index client and create the index.\n",
+    "AzureKeyCredential indexCredential = new AzureKeyCredential(azure_ai_search_api_key);\n",
+    "SearchIndexClient indexClient = new SearchIndexClient(new Uri(azure_ai_search_endpoint), indexCredential);\n",
     "indexClient.CreateOrUpdateIndex(searchIndex);\n",
     "\n",
-    "Console.WriteLine($\"Index {acs_index_name} created.\");"
+    "Console.WriteLine($\"Index {azure_ai_search_index_name} created.\");"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we will create the document structure needed to upload the data into the Azure Cognitive Search index.\n",
+    "The index is now ready, so next we need to prepare the movie data to load into the index.\n",
     "\n",
-    "**NOTE**: Be patient, creating the embeddings will take some time due to the Azure OpenAI embedding Token Per Minute (TPM) limits."
+    "**NOTE**: During this phase, we send the data for each movie to an Azure OpenAI embeddings model to create the vector data. This may take some time due to rate limiting in the API."
    ]
   },
   {
@@ -298,23 +448,48 @@
    },
    "outputs": [],
    "source": [
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
+    "using System.Text.RegularExpressions;\n",
     "\n",
-    "// Create structure to match the Azure Cognitive Search index.\n",
+    "// Loop through all of the movies and create an array of documents that we can load into the index.\n",
     "List<SearchDocument> movieDocuments = new List<SearchDocument>();\n",
     "for (int i = 0; i < movieSubset.Length; i++) \n",
     "{\n",
-    "    Console.WriteLine($\"Movie {i} being added.\");\n",
-    "    string id = System.Guid.NewGuid().ToString();\n",
-    "    string content = movieSubset[i];\n",
-    "    float[] contentEmbeddings = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(content)).Value.Data[0].Embedding.ToArray();\n",
+    "    // Extract the data for the movie from the CSV file into variables\n",
+    "    var values = Regex.Split(movieSubset[i], \",(?=(?:[^\\\"]*\\\"[^\\\"]*\\\")*[^\\\"]*$)\");\n",
+    "    var movieId = values[0];\n",
+    "    var movieTitle = values[2];\n",
+    "    var movieOverview = Regex.Replace(values[8], \"^\\\"|\\\"$\", \"\");\n",
+    "    var movieGenre = values[7].Substring(2, values[7].Length - 4);\n",
+    "    var movieTagline = Regex.Replace(values[11], \"^\\\"|\\\"$\", \"\");\n",
+    "    var movieReleaseDate = values[4];\n",
+    "    var movieRuntime = values[10];\n",
+    "    var moviePopularity = values[3];\n",
+    "    var movieVoteAverage = values[5];\n",
+    "    var movieVoteCount = values[6];\n",
+    "    var movieRevenue = values[9];\n",
+    "    var movieLanguage = values[1];\n",
+    "    \n",
+    "    // Take the entire set of data for the movie and generate the embeddings\n",
+    "    IEnumerable<string> content = new List<string>() { movieSubset[i] };\n",
+    "    Response<Embeddings> contentEmbeddings = azureOpenAIClient.GetEmbeddings(new EmbeddingsOptions(azure_openai_embedding_deployment_name, content));\n",
+    "\n",
+    "    // Add the movie data and embeddings to a search document\n",
     "    SearchDocument document = new SearchDocument();\n",
-    "    document.Add(\"id\", id);\n",
-    "    document.Add(\"content\", content);\n",
-    "    document.Add(\"content_vector\", contentEmbeddings);\n",
+    "    document.Add(\"id\", movieId.Substring(0, movieId.Length - 2));\n",
+    "    document.Add(\"title\", movieTitle);\n",
+    "    document.Add(\"overview\", movieOverview);\n",
+    "    document.Add(\"genre\", movieGenre);\n",
+    "    document.Add(\"tagline\", movieTagline);\n",
+    "    document.Add(\"release_date\", movieReleaseDate);\n",
+    "    document.Add(\"runtime\", movieRuntime);\n",
+    "    document.Add(\"popularity\", moviePopularity);\n",
+    "    document.Add(\"vote_average\", movieVoteAverage);\n",
+    "    document.Add(\"vote_count\", movieVoteCount);\n",
+    "    document.Add(\"revenue\", movieRevenue);\n",
+    "    document.Add(\"original_language\", movieLanguage);\n",
+    "    document.Add(\"vector\", contentEmbeddings.Value.Data[0].Embedding.ToArray());\n",
     "    movieDocuments.Add(new SearchDocument(document));\n",
-    "    Console.WriteLine($\"Movie {i} added.\");\n",
+    "    Console.WriteLine($\"Movie {movieTitle} added.\");\n",
     "}\n",
     "\n",
     "Console.WriteLine($\"New SearchDocument structure with embeddings created for {movieDocuments.Count} movies.\");"
@@ -324,7 +499,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we will upload the movie documents in the newly created structure to the Azure Cognitive Search index."
+    "We can write out the contents of one of the documents to see what it looks like. You can see that it contains the movie data at the top and then a long array containing the vector data."
    ]
   },
   {
@@ -343,29 +518,14 @@
    },
    "outputs": [],
    "source": [
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using Azure.Search.Documents.Indexes.Models;\n",
-    "\n",
-    "// Create an Azure Cognitive Search index client.\n",
-    "AzureKeyCredential indexCredential = new AzureKeyCredential(acs_api_key);\n",
-    "SearchIndexClient indexClient = new SearchIndexClient(new Uri(acs_endpoint_name), indexCredential);\n",
-    "SearchClient searchIndexClient = indexClient.GetSearchClient(acs_index_name);\n",
-    "\n",
-    "IndexDocumentsOptions options = new IndexDocumentsOptions { ThrowOnAnyError = true };\n",
-    "searchIndexClient.IndexDocuments(IndexDocumentsBatch.Upload(movieDocuments), options);\n",
-    "\n",
-    "Console.WriteLine($\"Successfully loaded {movieDocuments.Count} movies into Azure Cognitive Search index.\");"
+    "Console.WriteLine(movieDocuments[0]);"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Vector Store Searching using Azure Cognitive Search\n",
-    "\n",
-    "Now that we have the movies loaded into Azure Cognitive Search, let's do some different types of searches using the Azure Cognitive Search SDK."
+    "Now we have the movie data stored in the correct format, so let's load it into the Azure AI Search index we created earlier."
    ]
   },
   {
@@ -384,19 +544,22 @@
    },
    "outputs": [],
    "source": [
-    "// Setup an Azure Cognitive Search client for searching.\n",
+    "SearchClient searchIndexClient = indexClient.GetSearchClient(azure_ai_search_index_name);\n",
+    "IndexDocumentsOptions options = new IndexDocumentsOptions { ThrowOnAnyError = true };\n",
+    "searchIndexClient.IndexDocuments(IndexDocumentsBatch.Upload(movieDocuments), options);\n",
     "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
+    "Console.WriteLine($\"Successfully loaded {movieDocuments.Count} movies into Azure AI Search index.\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vector store searching using Azure AI Search\n",
     "\n",
-    "// Create a client\n",
-    "AzureKeyCredential credential = new AzureKeyCredential(acs_api_key);\n",
-    "SearchClient searchClient = new SearchClient(new Uri(acs_endpoint_name), acs_index_name, credential);\n",
+    "We've loaded the movies into Azure AI Search, so now let's experiment with some of the different types of searches you can perform.\n",
     "\n",
-    "Console.WriteLine($\"Successfully created Azure Cognitive Search SearchClient.\");"
+    "First we'll just perform a simple keyword search."
    ]
   },
   {
@@ -415,43 +578,36 @@
    },
    "outputs": [],
    "source": [
-    "// First, let's do a plain vanilla text search, no vectors or embeddings.\n",
-    "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"What are the best 80s movies I should look at?\";\n",
+    "var query = \"hero\";\n",
     "\n",
     "SearchOptions searchOptions = new SearchOptions\n",
     "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
     "    Size = 5,\n",
-    "    Select = { \"content\" },\n",
+    "    Select = { \"title\", \"genre\" },\n",
+    "    SearchMode = SearchMode.Any,\n",
+    "    QueryType = SearchQueryType.Simple,\n",
     "};\n",
     "\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(query, searchOptions);\n",
+    "SearchResults<SearchDocument> response = searchIndexClient.Search<SearchDocument>(query, searchOptions);\n",
     "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
     "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using only text-based search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
-    "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
     "foreach (SearchResult<SearchDocument> result in results)\n",
     "{\n",
-    "    Console.WriteLine($\"Movie: {result.Document[\"content\"]}\");\n",
+    "    Console.WriteLine($\"Movie: {result.Document[\"title\"]}\");\n",
+    "    Console.WriteLine($\"Genre: {result.Document[\"genre\"]}\");\n",
     "    Console.WriteLine(\"----------\");\n",
     "};"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We get some results, but they're not necessarily movies about heroes. It could be that there is some text in the index for these results that relates to the word \"hero\". For example, the description might mention \"heroic deeds\" or something similar.\n",
+    "\n",
+    "Let's now try the same again, but this time we'll ask a question instead of just searching for a keyword."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -468,44 +624,15 @@
    },
    "outputs": [],
    "source": [
-    "// Now let's do a vector search that uses the embeddings we created and inserted into content_vector field in the index.\n",
-    "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"What are the best 80s movies I should look at?\";\n",
-    "\n",
-    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(query)).Value.Data[0].Embedding.ToArray();\n",
-    "\n",
-    "// Note the Vectors addition in the SearchOptions\n",
-    "SearchOptions searchOptions = new SearchOptions\n",
-    "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
-    "    Size = 5,\n",
-    "    Select = { \"content\" },\n",
-    "};\n",
+    "var query = \"What are the best movies about superheroes?\";\n",
     "\n",
-    "// Note the search text is null when doing a vector search.\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(null, searchOptions);\n",
+    "SearchResults<SearchDocument> response = searchIndexClient.Search<SearchDocument>(query, searchOptions);\n",
     "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
     "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using only vector-based search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
-    "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
     "foreach (SearchResult<SearchDocument> result in results)\n",
     "{\n",
-    "    Console.WriteLine($\"Movie: {result.Document[\"content\"]}\");\n",
+    "    Console.WriteLine($\"Movie: {result.Document[\"title\"]}\");\n",
+    "    Console.WriteLine($\"Genre: {result.Document[\"genre\"]}\");\n",
     "    Console.WriteLine(\"----------\");\n",
     "};"
    ]
@@ -514,9 +641,9 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Did that return what you expected? Probably not, let's dig deeper to see why.\n",
+    "As before, you will likely get mixed results. Some of the movies returned could be about heroes, but others may not be. This is because the search is still based on keywords.\n",
     "\n",
-    "Let's do the same search again, but this time let's return the **Search Score** so we can see the value returned by the cosine similarity vector store calculation."
+    "Next, let's try a vector search."
    ]
   },
   {
@@ -535,45 +662,31 @@
    },
    "outputs": [],
    "source": [
-    "// Try again, but this time let's add the relevance score to maybe see why\n",
-    "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"What are the best 80s movies I should look at?\";\n",
+    "var query = \"What are the best movies about superheroes?\";\n",
     "\n",
-    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(query)).Value.Data[0].Embedding.ToArray();\n",
+    "// Convert the query to an embedding\n",
+    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(new EmbeddingsOptions(azure_openai_embedding_deployment_name, new List<string>() { query })).Value.Data[0].Embedding.ToArray();\n",
     "\n",
-    "// Note the Vectors addition in the SearchOptions\n",
+    "// This time we will set the search type to Semantic and we'll pass in the embedded version of the query text and parameters to configure the vector search.\n",
     "SearchOptions searchOptions = new SearchOptions\n",
     "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
+    "    QueryType = SearchQueryType.Semantic,\n",
+    "    SemanticConfigurationName = semanticSearchConfigName,\n",
+    "    VectorQueries = { new RawVectorQuery() { Vector = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"vector\" } } },\n",
     "    Size = 5,\n",
-    "    Select = { \"id\", \"content\" },\n",
+    "    Select = { \"title\", \"genre\" },\n",
     "};\n",
     "\n",
-    "// Note the search text is null when doing a vector search.\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(null, searchOptions);\n",
+    "// Note the `null` value for the query parameter. This is because we're not sending the query text to Azure AI Search. We're sending the embedded version of the query text instead.\n",
+    "SearchResults<SearchDocument> response = searchIndexClient.Search<SearchDocument>(null, searchOptions);\n",
     "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
     "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using only vector-based search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
-    "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
     "foreach (SearchResult<SearchDocument> result in results)\n",
     "{\n",
-    "    Console.WriteLine($\"Id: {result.Document[\"id\"]}\");\n",
+    "    Console.WriteLine($\"Movie: {result.Document[\"title\"]}\");\n",
+    "    Console.WriteLine($\"Genre: {result.Document[\"genre\"]}\");\n",
     "    Console.WriteLine($\"Score: {result.Score}\");\n",
+    "    //Console.WriteLine($\"Reranked Score: {result.RerankerScore}\");\n",
     "    Console.WriteLine(\"----------\");\n",
     "};"
    ]
@@ -582,7 +695,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you look at the Search Score you will see the relevant ranking of the closest vector match to the query inputted. The lower the score the farther apart the two vectors are. Let's change the search term and see if we can get a higher Search Score which means a higher match and closer vector proximity."
+    "It's likely that the raw vector search didn't return exactly what you were expecting. You were probably expecting a list of superhero movies, but now we're getting a list of movies that are **similar** to the vector we provided. Some of these may be hero movies, but others may not be. The vector search is returning the nearest neighbours to the vector we provided, so it's possible that at least one of the results is a superhero movie, and the others are similar to that movie in some way.\n",
+    "\n",
+    "So, both the keyword search and the vector search have their limitations. The keyword search is limited to the keywords in the index, so it's possible that we might miss some movies that are about heroes. The vector search is limited to returning the nearest neighbours to the vector we provide, so it's possible that we might get some movies that are not about heroes.\n",
+    "\n",
+    "## Hybrid search using Azure AI Search\n",
+    "\n",
+    "To overcome the limitations of both keyword search and vector search, we can use a combination of both. This is known as Hybrid Search. Let's run the same query again, but this time we'll use Hybrid Search.\n",
+    "\n",
+    "The only significant difference is that this time we will submit both the original query text and the embedding vector to Azure AI Search. Azure AI Search will then use both the query text and the vector to perform the search and combine the results."
    ]
   },
   {
@@ -601,45 +722,15 @@
    },
    "outputs": [],
    "source": [
-    "// Try again, but this time let's add the relevance score to maybe see why\n",
-    "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"Who are the actors in the movie Hidden Figures?\";\n",
-    "\n",
-    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(query)).Value.Data[0].Embedding.ToArray();\n",
-    "\n",
-    "// Note the Vectors addition in the SearchOptions\n",
-    "SearchOptions searchOptions = new SearchOptions\n",
-    "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
-    "    Size = 5,\n",
-    "    Select = { \"id\", \"content\" },\n",
-    "};\n",
-    "\n",
-    "// Note the search text is null when doing a vector search.\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(null, searchOptions);\n",
+    "SearchResults<SearchDocument> response = searchIndexClient.Search<SearchDocument>(query, searchOptions);\n",
     "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
     "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using only vector-based search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
-    "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
     "foreach (SearchResult<SearchDocument> result in results)\n",
     "{\n",
-    "    Console.WriteLine($\"Id: {result.Document[\"id\"]}\");\n",
+    "    Console.WriteLine($\"Movie: {result.Document[\"title\"]}\");\n",
+    "    Console.WriteLine($\"Genre: {result.Document[\"genre\"]}\");\n",
     "    Console.WriteLine($\"Score: {result.Score}\");\n",
+    "    Console.WriteLine($\"Reranked Score: {result.RerankerScore}\");\n",
     "    Console.WriteLine(\"----------\");\n",
     "};"
    ]
@@ -648,18 +739,27 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**NOTE:** As you have seen from the results, different inputs can return different results, it all depends on what data is in the Vector Store. The higher the score the higher the likelihood of a match."
+    "Hopefully, you'll now see a much better set of results. Performing a hybrid search has allowed us to combine the benefits of both keyword search and vector search. But also, Azure AI Search performs a further step when using hybrid search. It makes use of a Semantic Ranker to further improve the search results. The Semantic Ranker uses a language understanding model to understand the query text and the documents in the index and then uses this information to rerank the search results. So, after performing the keyword and vector search, Azure AI Search will then use the Semantic Ranker to re-order the search results based on the context of the original query.\n",
+    "\n",
+    "In the results above, you can see a `Reranked Score`. This is the score that has been calculated by the Semantic Ranker. The `Score` is the score calculated by the keyword and vector search. You'll note that the results are returned in the order determined by the reranked score."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Hybrid Searching using Azure Cognitive Search\n",
+    "## Bringing it All Together with Retrieval Augmented Generation (RAG) + Semantic Kernel (SK)\n",
+    "\n",
+    "Now that we have our Vector Store setup and data loaded, we are now ready to implement the RAG pattern using AI Orchestration. At a high-level, the following steps are required:\n",
+    "1. Ask the question\n",
+    "2. Create Prompt Template with inputs\n",
+    "3. Get Embedding representation of inputted question\n",
+    "4. Use embedded version of the question to search Azure AI Search (ie. The Vector Store)\n",
+    "5. Inject the results of the search into the Prompt Template & Execute the Prompt to get the completion\n",
     "\n",
-    "What is Hybrid Search? The search is implemented at the field level, which means you can build queries that include vector fields and searchable text fields. The queries execute in parallel and the results are merged into a single response. Optionally, add semantic search, currently in preview, for even more accuracy with L2 reranking using the same language models that power Bing.\n",
+    "**NOTE:** Semantic Kernel has a Semantic Memory feature, as well as a separate Kernel Memory project, that both allow you to store and retrieve information from a vector store. These are both currently in preview / experimental states. In the following code, we're implementing the feature using our own code to firstly retrieve results from Azure AI Search, then add those search results to the query we send to Azure OpenAI.\n",
     "\n",
-    "**NOTE:** Hybrid Search is a key value proposition of Azure Cognitive Search in comparison to vector only data stores."
+    "First, let's setup the packages and load the values from the `.env` file."
    ]
   },
   {
@@ -678,48 +778,58 @@
    },
    "outputs": [],
    "source": [
-    "// Hybrid Search\n",
-    "// Let's try our original query again using Hybrid Search (ie. Combination of Text & Vector Search)\n",
+    "// Add the Packages\n",
+    "#r \"nuget: dotenv.net, 3.1.2\"\n",
+    "#r \"nuget: Microsoft.SemanticKernel, 1.0.1\"\n",
+    "#r \"nuget: Microsoft.SemanticKernel.Connectors.OpenAI, 1.0.1\"\n",
+    "#r \"nuget: Azure.AI.OpenAI, 1.0.0-beta.12\"\n",
+    "#r \"nuget: Azure.Identity, 1.10.4\"\n",
+    "#r \"nuget: Azure.Search.Documents, 11.5.0-beta.5\"\n",
+    "#r \"nuget: Microsoft.Extensions.Logging, 7.0.0\"\n",
+    "#r \"nuget: Microsoft.Extensions.Logging.Console, 7.0.0\"\n",
     "\n",
+    "using System.IO;\n",
+    "using dotenv.net;\n",
+    "using Microsoft.SemanticKernel;\n",
+    "using Microsoft.SemanticKernel.Connectors.OpenAI;\n",
     "using Azure;\n",
+    "using Azure.AI.OpenAI;\n",
+    "using Azure.Identity;\n",
     "using Azure.Search.Documents;\n",
     "using Azure.Search.Documents.Models;\n",
     "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"What are the best 80s movies I should look at?\";\n",
-    "\n",
-    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(query)).Value.Data[0].Embedding.ToArray();\n",
-    "\n",
-    "// Note the Vectors addition in the SearchOptions\n",
-    "SearchOptions searchOptions = new SearchOptions\n",
-    "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
-    "    Size = 5,\n",
-    "    Select = { \"id\", \"content\" },\n",
-    "};\n",
-    "\n",
-    "// Note the search text and the vector search are both filled in.\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(query, searchOptions);\n",
-    "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
-    "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using hybrid search search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
+    "using Azure.Search.Documents.Indexes.Models;\n",
+    "using Microsoft.Extensions.Configuration;\n",
     "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
-    "foreach (SearchResult<SearchDocument> result in results)\n",
-    "{\n",
-    "    Console.WriteLine($\"Id: {result.Document[\"id\"]}\");\n",
-    "    Console.WriteLine($\"Score: {result.Score}\");\n",
-    "    Console.WriteLine(\"----------\");\n",
-    "};"
+    "// Read values from .env file\n",
+    "var envVars = DotEnv.Fluent()\n",
+    "    .WithoutExceptions()\n",
+    "    .WithEnvFiles(\"../../../.env\")\n",
+    "    .WithTrimValues()\n",
+    "    .WithDefaultEncoding()\n",
+    "    .WithOverwriteExistingVars()\n",
+    "    .WithoutProbeForEnv()\n",
+    "    .Read();\n",
+    "\n",
+    "var azure_openai_api_key = envVars[\"AZURE_OPENAI_API_KEY\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_openai_endpoint = envVars[\"AZURE_OPENAI_ENDPOINT\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_openai_completion_deployment_name = envVars[\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_openai_embedding_deployment_name = envVars[\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_name = envVars[\"AZURE_AI_SEARCH_SERVICE_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_endpoint = envVars[\"AZURE_AI_SEARCH_ENDPOINT\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_api_key = envVars[\"AZURE_AI_SEARCH_API_KEY\"].Replace(\"\\\"\", \"\");\n",
+    "var azure_ai_search_index_name = envVars[\"AZURE_AI_SEARCH_INDEX_NAME\"].Replace(\"\\\"\", \"\");\n",
+    "\n",
+    "Console.WriteLine(\"This lab exercise will use the following values:\");\n",
+    "Console.WriteLine($\"Azure OpenAI Endpoint: {azure_openai_endpoint}\");\n",
+    "Console.WriteLine($\"Azure AI Search: {azure_ai_search_name}\");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll setup Semantic Kernel with an Azure OpenAI service."
    ]
   },
   {
@@ -738,62 +848,16 @@
    },
    "outputs": [],
    "source": [
-    "// Hybrid Search\n",
-    "// Let's try our more specific query again to see the difference in the score returned.\n",
-    "\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using System.Text.Json.Serialization;\n",
-    "\n",
-    "var query = \"Who are the actors in the movie Hidden Figures?\";\n",
-    "\n",
-    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(query)).Value.Data[0].Embedding.ToArray();\n",
-    "\n",
-    "// Note the Vectors addition in the SearchOptions\n",
-    "SearchOptions searchOptions = new SearchOptions\n",
-    "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
-    "    Size = 5,\n",
-    "    Select = { \"id\", \"content\" },\n",
-    "};\n",
-    "\n",
-    "// Note the search text and the vector search are both filled in.\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(query, searchOptions);\n",
-    "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
-    "\n",
-    "// Print count of total results.\n",
-    "Console.WriteLine($\"Returned {results.Count()} results using hybrid search search.\");\n",
-    "Console.WriteLine(\"----------\");\n",
-    "\n",
-    "// Iterate over Results\n",
-    "// Index Fields - id, content, content_vector\n",
-    "foreach (SearchResult<SearchDocument> result in results)\n",
-    "{\n",
-    "    Console.WriteLine($\"Id: {result.Document[\"id\"]}\");\n",
-    "    Console.WriteLine($\"Score: {result.Score}\");\n",
-    "    Console.WriteLine(\"----------\");\n",
-    "};"
+    "var builder = Kernel.CreateBuilder();\n",
+    "builder.Services.AddAzureOpenAIChatCompletion(azure_openai_completion_deployment_name, azure_openai_endpoint, azure_openai_api_key);\n",
+    "var kernel = builder.Build();"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Bringing it All Together with Retrieval Augmented Generation (RAG) + Semantic Kernel (SK)\n",
-    "\n",
-    "Now that we have our Vector Store setup and data loaded, we are now ready to implement the RAG pattern using AI Orchestration. At a high-level, the following steps are required:\n",
-    "1. Ask the question\n",
-    "2. Create Prompt Template with inputs\n",
-    "3. Get Embedding representation of inputted question\n",
-    "4. Use embedded version of the question to search Azure Cognitive Search (ie. The Vector Store)\n",
-    "5. Inject the results of the search into the Prompt Template & Execute the Prompt to get the completion"
+    "Now we need to define a prompt template. In this template, we'll give the model the `System` instructions telling it to answer the users question using only the data provided. We'll then inject the search results that we'll later get from Azure AI Search into the `searchResults` variable. The `User` instructions will be the question that the user asks."
    ]
   },
   {
@@ -812,159 +876,186 @@
    },
    "outputs": [],
    "source": [
-    "// Implement RAG using Semantic Kernel (SK)\n",
-    "\n",
-    "// Add the Packages\n",
-    "#r \"nuget: DotNetEnv, 2.5.0\"\n",
-    "#r \"nuget: Microsoft.SemanticKernel, 0.24.230918.1-preview\"\n",
-    "#r \"nuget: Microsoft.SemanticKernel.Abstractions, 0.24.230918.1-preview\"\n",
-    "#r \"nuget: Azure.AI.OpenAI, 1.0.0-beta.7\"\n",
-    "#r \"nuget: Azure.Identity, 1.10.1\"\n",
-    "#r \"nuget: Azure.Search.Documents, 11.5.0-beta.4\"\n",
-    "#r \"nuget: Microsoft.Extensions.Logging, 7.0.0\"\n",
-    "#r \"nuget: Microsoft.Extensions.Logging.Console, 7.0.0\"\n",
-    "\n",
-    "using System.IO;\n",
-    "using Microsoft.SemanticKernel;\n",
-    "using Microsoft.SemanticKernel.SemanticFunctions;\n",
-    "using Microsoft.SemanticKernel.Orchestration;\n",
-    "using Microsoft.SemanticKernel.SkillDefinition;\n",
-    "using Azure;\n",
-    "using Azure.Search.Documents;\n",
-    "using Azure.Search.Documents.Models;\n",
-    "using Azure.Search.Documents.Indexes;\n",
-    "using Azure.AI.OpenAI;\n",
-    "using Azure.Identity;\n",
-    "\n",
-    "// Read values from .env file\n",
-    "DotNetEnv.Env.Load(\"../../../.env\");\n",
-    "\n",
-    "// Load values into variables\n",
-    "var openai_api_type = System.Environment.GetEnvironmentVariable(\"OPENAI_API_TYPE\");\n",
-    "var openai_api_key = System.Environment.GetEnvironmentVariable(\"OPENAI_API_KEY\");\n",
-    "var openai_api_base = System.Environment.GetEnvironmentVariable(\"OPENAI_API_BASE\");\n",
-    "var openai_api_version = System.Environment.GetEnvironmentVariable(\"OPENAI_API_VERSION\");\n",
-    "var deployment_name = System.Environment.GetEnvironmentVariable(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\");\n",
-    "var embedding_name = System.Environment.GetEnvironmentVariable(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\");\n",
-    "var acs_service_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_SERVICE_NAME\");\n",
-    "var acs_endpoint_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME\");\n",
-    "var acs_index_name = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_INDEX_NAME\");\n",
-    "var acs_api_key = System.Environment.GetEnvironmentVariable(\"AZURE_COGNITIVE_SEARCH_API_KEY\");\n",
-    "\n",
-    "Console.WriteLine(\"Environment Variables loaded.\");\n",
-    "\n",
-    "// Setup Semantic Kernel\n",
-    "IKernel kernel = Kernel.Builder\n",
-    "    .WithAzureChatCompletionService(deployment_name, openai_api_base, openai_api_key)\n",
-    "    .WithAzureTextEmbeddingGenerationService(embedding_name, openai_api_base, openai_api_key)\n",
-    "    .Build();\n",
-    "\n",
-    "Console.WriteLine(\"SK Kernel with ChatCompletion and EmbeddingsGeneration services created.\");\n",
-    "\n",
-    "// Ask the question\n",
-    "var question = \"List the movies about ships on the water.\";\n",
-    "\n",
-    "// Create a prompt template with variables, note the double curly braces with dollar sign for the variables\n",
-    "// First let's create the prompt string.\n",
-    "var sk_prompt = @\"\n",
-    "Question: {{$original_question}}\n",
-    "\n",
-    "Do not use any other data.\n",
-    "Only use the movie data below when responding.\n",
-    "{{$search_results}}\n",
-    "\";\n",
-    "// Create the PromptTemplateConfig\n",
-    "PromptTemplateConfig promptConfig = new PromptTemplateConfig\n",
-    "{\n",
-    "    Schema = 1,\n",
-    "    Type = \"completion\",\n",
-    "    Description = \"Gets the intent of the user.\",\n",
-    "    Completion = \n",
+    "var askQuery = kernel.CreateFunctionFromPrompt(\n",
+    "    new PromptTemplateConfig()\n",
     "    {\n",
-    "        Temperature = 0.1,\n",
-    "        TopP = 0.5,\n",
-    "        PresencePenalty = 0.0,\n",
-    "        FrequencyPenalty = 0.0,\n",
-    "        MaxTokens = 500\n",
-    "        // StopSequences = null,\n",
-    "        // ChatSystemPprompt = null;\n",
-    "    },\n",
-    "    Input = \n",
-    "    {\n",
-    "        Parameters = new List<PromptTemplateConfig.InputParameter>\n",
-    "        {\n",
-    "            new PromptTemplateConfig.InputParameter\n",
-    "            {\n",
-    "                Name=\"original_question\",\n",
-    "                Description=\"The user's request.\",\n",
-    "                DefaultValue=\"\"\n",
-    "            },\n",
-    "            new PromptTemplateConfig.InputParameter\n",
-    "            {\n",
-    "                Name=\"search_results\",\n",
-    "                Description=\"Vector Search results from Azure Cognitive Search.\",\n",
-    "                DefaultValue=\"\"\n",
-    "            }\n",
+    "        Name = \"askQuery\",\n",
+    "        Description = \"Ask Azure OpenAI a question using results from Azure AI Search.\",\n",
+    "        Template = @\"System: Answer the user's question using only the movie data below. Do not use any other data. Provide detailed information about the synopsis of the movie. {{$searchResults}}\n",
+    "        User: {{$originalQuestion}}\n",
+    "        Assistant: \",\n",
+    "        TemplateFormat = \"semantic-kernel\",\n",
+    "        InputVariables = [\n",
+    "            new() { Name = \"originalQuestion\", Description = \"The query we sent to Azure AI Search.\", IsRequired = true },\n",
+    "            new() { Name = \"searchResults\", Description = \"The results retrieved from Azure AI Search.\", IsRequired = true }\n",
+    "        ],\n",
+    "        ExecutionSettings = {\n",
+    "            { \"default\", new OpenAIPromptExecutionSettings() {\n",
+    "                MaxTokens = 1000,\n",
+    "                Temperature = 0.1,\n",
+    "                TopP = 0.5,\n",
+    "                PresencePenalty = 0.0,\n",
+    "                FrequencyPenalty = 0.0\n",
+    "            } }\n",
     "        }\n",
     "    }\n",
-    "};\n",
-    "// Create the SemanticFunctionConfig object\n",
-    "PromptTemplate promptTemplate = new PromptTemplate(\n",
-    "    sk_prompt,\n",
-    "    promptConfig,\n",
-    "    kernel\n",
-    ");\n",
-    "SemanticFunctionConfig functionConfig = new SemanticFunctionConfig(promptConfig, promptTemplate);\n",
-    "// Register the GetIntent function with the Kernel\n",
-    "ISKFunction getIntentFunction = kernel.RegisterSemanticFunction(\"CustomPlugin\", \"GetIntent\", functionConfig);\n",
-    "\n",
-    "Console.WriteLine(\"Semantic Function GetIntent with SK has been completed.\");\n",
-    "\n",
-    "// Get Embedding for the original question\n",
-    "OpenAIClient azureOpenAIClient = new OpenAIClient(new Uri(openai_api_base),new AzureKeyCredential(openai_api_key));\n",
-    "float[] questionEmbedding = azureOpenAIClient.GetEmbeddings(embedding_name, new EmbeddingsOptions(question)).Value.Data[0].Embedding.ToArray();\n",
+    ");"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next we define our question and send the question to an embedding model to generate the vector representation of the question."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "var query = \"What are the best movies about superheroes?\";\n",
     "\n",
-    "Console.WriteLine(\"Embedding of original question has been completed.\");\n",
+    "OpenAIClient azureOpenAIClient = new OpenAIClient(new Uri(azure_openai_endpoint),new AzureKeyCredential(azure_openai_api_key));\n",
+    "float[] queryEmbedding = azureOpenAIClient.GetEmbeddings(new EmbeddingsOptions(azure_openai_embedding_deployment_name, new List<string>() { query })).Value.Data[0].Embedding.ToArray();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Let's prepare the `SearchOptions` to carry out a vector search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "string semanticSearchConfigName = \"movies-semantic-config\";\n",
     "\n",
-    "// Search Vector Store\n",
     "SearchOptions searchOptions = new SearchOptions\n",
     "{\n",
-    "    // Filter to only Content greater than or equal our preference\n",
-    "    // Filter = SearchFilter.Create($\"Content ge {content}\"),\n",
-    "    // OrderBy = { \"Content desc\" } // Sort by Content from high to low\n",
-    "    // Size = 5, // Take only 5 results\n",
-    "    // Select = { \"id\", \"content\", \"content_vector\" }, // Which fields to return\n",
-    "    Vectors = { new() { Value = questionEmbedding, KNearestNeighborsCount = 5, Fields = { \"content_vector\" } } }, // Vector Search\n",
+    "    QueryType = SearchQueryType.Semantic,\n",
+    "    SemanticConfigurationName = semanticSearchConfigName,\n",
+    "    VectorQueries = { new RawVectorQuery() { Vector = queryEmbedding, KNearestNeighborsCount = 5, Fields = { \"vector\" } } },\n",
     "    Size = 5,\n",
-    "    Select = { \"id\", \"content\" },\n",
-    "};\n",
+    "    Select = { \"title\", \"genre\" },\n",
+    "};"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can go ahead and perform the search. As noted previously, we'll provide both the original question text and the vector representation of the text in order to perform a hybrid search with semantic ranking."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "AzureKeyCredential indexCredential = new AzureKeyCredential(azure_ai_search_api_key);\n",
+    "SearchIndexClient indexClient = new SearchIndexClient(new Uri(azure_ai_search_endpoint), indexCredential);\n",
+    "SearchClient searchClient = indexClient.GetSearchClient(azure_ai_search_index_name);\n",
     "\n",
-    "// Note the search text is null and the vector search is filled in.\n",
-    "AzureKeyCredential credential = new AzureKeyCredential(acs_api_key);\n",
-    "SearchClient searchClient = new SearchClient(new Uri(acs_endpoint_name), acs_index_name, credential);\n",
-    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(null, searchOptions);\n",
-    "Pageable<SearchResult<SearchDocument>> results = response.GetResults();\n",
-    "// Create string from the results\n",
+    "//Perform the search\n",
+    "SearchResults<SearchDocument> response = searchClient.Search<SearchDocument>(query, searchOptions);\n",
+    "Pageable<SearchResult<SearchDocument>> results = response.GetResults();"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The results of the search are now in the `results` variable. We'll iterate through them and turn them into a string that we can inject into the prompt template. When finished, we display these results so that you can see what is going to be injected into the template."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
     "StringBuilder stringBuilderResults = new StringBuilder();\n",
     "foreach (SearchResult<SearchDocument> result in results)\n",
     "{\n",
-    "    stringBuilderResults.AppendLine($\"{result.Document[\"content\"]}\");\n",
+    "    stringBuilderResults.AppendLine($\"{result.Document[\"title\"]}\");\n",
     "};\n",
     "\n",
-    "Console.WriteLine(\"Searching of Vector Store has been completed.\");\n",
-    "\n",
-    "// Build the Prompt and Execute against the Azure OpenAI to get the completion\n",
-    "// Initialize the prompt variables\n",
-    "ContextVariables variables = new ContextVariables\n",
-    "{\n",
-    "    [\"original_question\"] = question,\n",
-    "    [\"search_results\"] = stringBuilderResults.ToString()\n",
-    "};\n",
-    "// Use SK Chaining to Invoke Semantic Function\n",
-    "string completion = (await kernel.RunAsync(variables, getIntentFunction)).Result;\n",
-    "Console.WriteLine(completion);\n",
+    "Console.WriteLine(stringBuilderResults.ToString());"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we can inject the search results into the prompt template and execute the prompt to get the completion."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "dotnet_interactive": {
+     "language": "csharp"
+    },
+    "polyglot_notebook": {
+     "kernelName": "csharp"
+    },
+    "vscode": {
+     "languageId": "polyglot-notebook"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "var completion = await kernel.InvokeAsync(askQuery, new () { { \"originalQuestion\", query }, { \"searchResults\", stringBuilderResults.ToString() }});\n",
     "\n",
-    "Console.WriteLine(\"Implementation of RAG using SK, C# and Azure Cognitive Search has been completed.\");"
+    "Console.WriteLine(completion);"
    ]
   },
   {
@@ -993,7 +1084,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.5"
+   "version": "3.11.6"
   },
   "orig_nbformat": 4
  },
diff --git a/labs/03-orchestration/04-ACS/acs-sk-python.ipynb b/labs/03-orchestration/04-ACS/acs-sk-python.ipynb
deleted file mode 100644
index 3128d39..0000000
--- a/labs/03-orchestration/04-ACS/acs-sk-python.ipynb
+++ /dev/null
@@ -1,788 +0,0 @@
-{
- "cells": [
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 04 - AI Orchestration with Azure Cognitive Search\n",
-    "\n",
-    "In this lab, we will do a deeper dive around the Azure Cognitive Search vector store and different ways to interact with it."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Create Azure Cognitive Search Vector Store in Azure\n",
-    "\n",
-    "First, we need to create an Azure Cognitive Search service in Azure, which will act as a vector store. We'll use the Azure CLI to do this.\n",
-    "\n",
-    "**NOTE:** Update **`<INITIALS>`** to make the name unique."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "RESOURCE_GROUP=\"azure-cognitive-search-rg\"\n",
-    "LOCATION=\"westeurope\"\n",
-    "NAME=\"acs-vectorstore-<INITIALS>\"\n",
-    "!az group create --name $RESOURCE_GROUP --location $LOCATION\n",
-    "!az search service create -g $RESOURCE_GROUP -n $NAME -l $LOCATION --sku Basic --partition-count 1 --replica-count 1"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next, we need to find and update the following values in the `.env` file with the Azure Cognitive Search **endpoint**, **admin key**, and **index name** values. Use the Azure Portal or CLI.\n",
-    "\n",
-    "```\n",
-    "AZURE_COGNITIVE_SEARCH_SERVICE_NAME = \"<YOUR AZURE COGNITIVE SEARCH SERVICE NAME - e.g. cognitive-search-service>\"\n",
-    "AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME = \"<YOUR AZURE COGNITIVE SEARCH ENDPOINT NAME - e.g. https://cognitive-search-service.search.windows.net\"\n",
-    "AZURE_COGNITIVE_SEARCH_INDEX_NAME = \"<YOUR AZURE COGNITIVE SEARCH INDEX NAME - e.g. cognitive-search-index>\"\n",
-    "AZURE_COGNITIVE_SEARCH_API_KEY = \"<YOUR AZURE COGNITIVE SEARCH ADMIN API KEY - e.g. cognitive-search-admin-api-key>\"\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Setup Azure OpenAI\n",
-    "\n",
-    "We'll start as usual by defining our Azure OpenAI service API key and endpoint details, specifying the model deployment we want to use and then we'll initiate a connection to the Azure OpenAI service.\n",
-    "\n",
-    "**NOTE**: As with previous labs, we'll use the values from the `.env` file in the root of this repository."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "from dotenv import load_dotenv\n",
-    "\n",
-    "# Load environment variables\n",
-    "if load_dotenv():\n",
-    "    print(\"Found OpenAPI Base Endpoint: \" + os.getenv(\"OPENAI_API_BASE\"))\n",
-    "else: \n",
-    "    print(\"No file .env found\")\n",
-    "\n",
-    "openai_api_type = os.getenv(\"OPENAI_API_TYPE\")\n",
-    "openai_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
-    "openai_api_base = os.getenv(\"OPENAI_API_BASE\")\n",
-    "openai_api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
-    "deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
-    "embedding_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")\n",
-    "acs_service_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_SERVICE_NAME\")\n",
-    "acs_endpoint_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_ENDPOINT_NAME\")\n",
-    "acs_index_name = os.getenv(\"AZURE_COGNITIVE_SEARCH_INDEX_NAME\")\n",
-    "acs_api_key = os.getenv(\"AZURE_COGNITIVE_SEARCH_API_KEY\")"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "First, we will load the data from the movies.csv file using the Langchain CSV document loader."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.document_loaders.csv_loader import CSVLoader\n",
-    "\n",
-    "# Movie Fields in CSV\n",
-    "# id,original_language,original_title,popularity,release_date,vote_average,vote_count,genre,overview,revenue,runtime,tagline\n",
-    "loader = CSVLoader(file_path='./movies.csv', source_column='original_title', encoding='utf-8', csv_args={'delimiter':',', 'fieldnames': ['id', 'original_language', 'original_title', 'popularity', 'release_date', 'vote_average', 'vote_count', 'genre', 'overview', 'revenue', 'runtime', 'tagline']})\n",
-    "data = loader.load()\n",
-    "data = data[1:51] # reduce dataset if you want\n",
-    "print('Loaded %s movies' % len(data))"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next, we will create an Azure OpenAI embedding and completion deployments in order to create the vector representation of the movies so we can start asking our questions."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
-    "from langchain.chat_models import AzureChatOpenAI\n",
-    "\n",
-    "# Create an Embeddings Instance of Azure OpenAI\n",
-    "embeddings = OpenAIEmbeddings(\n",
-    "    model=\"text-embedding-ada-002\",\n",
-    "    deployment=embedding_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    embedding_ctx_length=8191,\n",
-    "    chunk_size=1000,\n",
-    "    max_retries=6\n",
-    ")\n",
-    "\n",
-    "# Create a Completion Instance of Azure OpenAI\n",
-    "llm = AzureChatOpenAI(\n",
-    "    model=\"gpt-3.5-turbo\",\n",
-    "    deployment_name = deployment_name,\n",
-    "    openai_api_type = openai_api_type,\n",
-    "    openai_api_version = openai_api_version,\n",
-    "    openai_api_base = openai_api_base,\n",
-    "    openai_api_key = openai_api_key,\n",
-    "    temperature=0.7,\n",
-    "    max_retries=6,\n",
-    "    max_tokens=4000\n",
-    ")\n",
-    "\n",
-    "print('Completed creation of embedding and completion instances.')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Load Movies into Azure Cognitive Search\n",
-    "\n",
-    "Next, we'll create the Azure Cognitive Search index, embed the loaded movies from the CSV file, and upload the data into the newly created index. Depending on the number of movies loaded and rate limiting, this might take a while to do the embeddings so be patient."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from azure.core.credentials import AzureKeyCredential\n",
-    "from azure.search.documents.indexes import SearchIndexClient\n",
-    "from azure.search.documents.indexes.models import (\n",
-    "    SearchIndex,\n",
-    "    SearchField,\n",
-    "    SearchFieldDataType,\n",
-    "    SimpleField,\n",
-    "    SearchableField,\n",
-    "    SearchIndex,\n",
-    "    SemanticConfiguration,\n",
-    "    PrioritizedFields,\n",
-    "    SemanticField,\n",
-    "    SearchField,\n",
-    "    SemanticSettings,\n",
-    "    VectorSearch,\n",
-    "    HnswVectorSearchAlgorithmConfiguration,\n",
-    ")\n",
-    "\n",
-    "# Let's Create the Azure Cognitive Search Index\n",
-    "index_client = SearchIndexClient(\n",
-    "    acs_endpoint_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "# Movie Fields in CSV\n",
-    "# id,original_language,original_title,popularity,release_date,vote_average,vote_count,genre,overview,revenue,runtime,tagline\n",
-    "fields = [\n",
-    "    SimpleField(name=\"id\", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True),\n",
-    "    SearchableField(name=\"content\", type=SearchFieldDataType.String),\n",
-    "    SearchField(name=\"content_vector\", type=SearchFieldDataType.Collection(SearchFieldDataType.Single), searchable=True, vector_search_dimensions=1536, vector_search_configuration=\"my-vector-config\"),\n",
-    "]\n",
-    "\n",
-    "# Configure Vector Search Configuration\n",
-    "vector_search = VectorSearch(\n",
-    "    algorithm_configurations=[\n",
-    "        HnswVectorSearchAlgorithmConfiguration(\n",
-    "            name=\"my-vector-config\",\n",
-    "            kind=\"hnsw\",\n",
-    "            parameters={\n",
-    "                \"m\": 4,\n",
-    "                \"efConstruction\": 400,\n",
-    "                \"efSearch\": 500,\n",
-    "                \"metric\": \"cosine\"\n",
-    "            }\n",
-    "        )\n",
-    "    ]\n",
-    ")\n",
-    "\n",
-    "# Configure Semantic Configuration\n",
-    "semantic_config = SemanticConfiguration(\n",
-    "    name=\"my-semantic-config\",\n",
-    "    prioritized_fields=PrioritizedFields(\n",
-    "        title_field=SemanticField(field_name=\"content\"),\n",
-    "        prioritized_keywords_fields=[SemanticField(field_name=\"content\")],\n",
-    "        prioritized_content_fields=[SemanticField(field_name=\"content\")]\n",
-    "    )\n",
-    ")\n",
-    "\n",
-    "# Create the semantic settings with the configuration\n",
-    "semantic_settings = SemanticSettings(configurations=[semantic_config])\n",
-    "\n",
-    "# Create the search index with the desired vector search and semantic configurations\n",
-    "index = SearchIndex(\n",
-    "    name=acs_index_name,\n",
-    "    fields=fields,\n",
-    "    vector_search=vector_search,\n",
-    "    semantic_settings=semantic_settings\n",
-    ")\n",
-    "result = index_client.create_or_update_index(index)\n",
-    "print(f'The {result.name} index was created.')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next we will create the document structure needed to upload the data into the Azure Cognitive Search index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now that the index is created, let's load the documents into it.\n",
-    "\n",
-    "import uuid\n",
-    "\n",
-    "# Let's take a quick look at the data structure of the CSVLoader\n",
-    "print(data[0])\n",
-    "print(\"----------\")\n",
-    "\n",
-    "# Generate Document Embeddings for page_content field in the movies CSVLoader dataset using Azure OpenAI\n",
-    "items = []\n",
-    "for movie in data:\n",
-    "    content = movie.page_content\n",
-    "    items.append(dict([(\"id\", str(uuid.uuid4())), (\"content\", content), (\"content_vector\", embeddings.embed_query(content))]))\n",
-    "\n",
-    "# Print out a sample item to validate the updated data structure.\n",
-    "# It should have the id, content, and content_vector values.\n",
-    "print(items[0])\n",
-    "print(f\"Movie Count: {len(items)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Next we will upload the movie documents in the newly created structure to the Azure Cognitive Search index."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Upload movies to Azure Cognitive Search index.\n",
-    "from azure.search.documents.models import Vector\n",
-    "from azure.search.documents import SearchClient\n",
-    "\n",
-    "# Insert Text and Embeddings into the Azure Cognitive Search index created.\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "result = search_client.upload_documents(items)\n",
-    "print(\"Successfully added documents to Azure Cognitive Search index.\")\n",
-    "print(f\"Uploaded {len(data)} documents\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Vector Store Searching using Azure Cognitive Search\n",
-    "\n",
-    "Now that we have the movies loaded into Azure Cognitive Search, let's do some different types of searches using the Azure Cognitive Search SDK."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# First, let's do a plain vanilla text search, no vectors or embeddings.\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
-    "results = list(search_client.search(\n",
-    "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=5\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using only text-based search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over Results\n",
-    "# Index Fields - id, content, content_vector\n",
-    "for result in results:\n",
-    "    print(\"Movie: {}\".format(result[\"content\"]))\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Now let's do a vector search that uses the embeddings we created and inserted into content_vector field in the index.\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
-    "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
-    "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using only vector-based search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the content.\n",
-    "for result in results:\n",
-    "    print(result[\"content\"])\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Did that return what you expected? Probably not, let's dig deeper to see why.\n",
-    "\n",
-    "Let's do the same search again, but this time let's return the **Search Score** so we can see the value returned by the cosine similarity vector store calculation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Try again, but this time let's add the relevance score to maybe see why\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
-    "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
-    "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Score: {result['@search.score']}\")\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "If you look at the Search Score you will see the relevant ranking of the closest vector match to the query inputted. The lower the score the farther apart the two vectors are. Let's change the search term and see if we can get a higher Search Score which means a higher match and closer vector proximity."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Try again, but this time let's add the relevance score to maybe see why\n",
-    "query = \"Who are the actors in the movie Hidden Figures?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Execute the search\n",
-    "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
-    "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Score: {result['@search.score']}\")\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**NOTE:** As you have seen from the results, different inputs can return different results, it all depends on what data is in the Vector Store. The higher the score the higher the likelihood of a match."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Hybrid Searching using Azure Cognitive Search\n",
-    "\n",
-    "What is Hybrid Search? The search is implemented at the field level, which means you can build queries that include vector fields and searchable text fields. The queries execute in parallel and the results are merged into a single response. Optionally, add semantic search, currently in preview, for even more accuracy with L2 reranking using the same language models that power Bing.\n",
-    "\n",
-    "**NOTE:** Hybrid Search is a key value proposition of Azure Cognitive Search in comparison to vector only data stores. Click [Hybrid Search](https://learn.microsoft.com/en-us/azure/search/hybrid-search-overview) for more details."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Hybrid Search\n",
-    "# Let's try our original query again using Hybrid Search (ie. Combination of Text & Vector Search)\n",
-    "query = \"What are the best 80s movies I should look at?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# Notice we also fill in the search_text parameter with the query.\n",
-    "results = list(search_client.search(\n",
-    "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=10,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using vector search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Hybrid Search Score: {result['@search.score']}\")\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Hybrid Search\n",
-    "# Let's try our more specific query again to see the difference in the score returned.\n",
-    "query = \"Who are the actors in the movie Hidden Figures?\"\n",
-    "\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "\n",
-    "# You can see here that we are getting the embedding representation of the query.\n",
-    "vector = Vector(\n",
-    "    value=embeddings.embed_query(query),\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "\n",
-    "# -----\n",
-    "# Notice we also fill in the search_text parameter with the query along with the vector.\n",
-    "# -----\n",
-    "results = list(search_client.search(\n",
-    "    search_text=query,\n",
-    "    include_total_count=True,\n",
-    "    top=10,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"id\", \"content\"],\n",
-    "))\n",
-    "\n",
-    "# Print count of total results.\n",
-    "print(f\"Returned {len(results)} results using hybrid search.\")\n",
-    "print(\"----------\")\n",
-    "# Iterate over results and print out the id and search score.\n",
-    "for result in results:  \n",
-    "    print(f\"Id: {result['id']}\")\n",
-    "    print(f\"Hybrid Search Score: {result['@search.score']}\")\n",
-    "    print(\"----------\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Bringing it All Together with Retrieval Augmented Generation (RAG) + Semantic Kernel (SK)\n",
-    "\n",
-    "Now that we have our Vector Store setup and data loaded, we are now ready to implement the RAG pattern using AI Orchestration. At a high-level, the following steps are required:\n",
-    "1. Ask the question\n",
-    "2. Create Prompt Template with inputs\n",
-    "3. Get Embedding representation of inputted question\n",
-    "4. Use embedded version of the question to search Azure Cognitive Search (ie. The Vector Store)\n",
-    "5. Inject the results of the search into the Prompt Template & Execute the Prompt to get the completion"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Implement RAG using Semantic Kernel (SK)\n",
-    "import asyncio\n",
-    "import semantic_kernel as sk\n",
-    "from semantic_kernel.connectors.ai.open_ai import (\n",
-    "    AzureChatCompletion,\n",
-    "    AzureTextEmbedding,\n",
-    ")\n",
-    "from semantic_kernel.connectors.memory.azure_cognitive_search import (\n",
-    "    AzureCognitiveSearchMemoryStore,\n",
-    ")\n",
-    "from semantic_kernel.semantic_functions.prompt_template import PromptTemplate\n",
-    "from semantic_kernel.semantic_functions.prompt_template_config import PromptTemplateConfig\n",
-    "from semantic_kernel.semantic_functions.semantic_function_config import SemanticFunctionConfig\n",
-    "from azure.search.documents.models import Vector\n",
-    "from azure.search.documents import SearchClient\n",
-    "from azure.search.documents.indexes import SearchIndexClient\n",
-    "from azure.search.documents.indexes.models import (\n",
-    "    SearchIndex,\n",
-    "    SearchField,\n",
-    "    SearchFieldDataType,\n",
-    "    SimpleField,\n",
-    "    SearchableField,\n",
-    "    SearchIndex,\n",
-    "    SemanticConfiguration,\n",
-    "    PrioritizedFields,\n",
-    "    SemanticField,\n",
-    "    SearchField,\n",
-    "    SemanticSettings,\n",
-    "    VectorSearch,\n",
-    "    HnswVectorSearchAlgorithmConfiguration,\n",
-    ")\n",
-    "from azure.core.credentials import AzureKeyCredential\n",
-    "\n",
-    "# Setup Semantic Kernel\n",
-    "my_logger = sk.NullLogger()\n",
-    "kernel = sk.Kernel(\n",
-    "    log=my_logger\n",
-    ")\n",
-    "\n",
-    "# Add Chat Service to SK\n",
-    "kernel.add_chat_service(\n",
-    "    \"gpt35turbo\",\n",
-    "    AzureChatCompletion(\n",
-    "        deployment_name=deployment_name,\n",
-    "        endpoint=openai_api_base,\n",
-    "        api_key=openai_api_key,\n",
-    "        logger=my_logger\n",
-    "    )\n",
-    ")\n",
-    "# Add Text Embeddings Service to SK\n",
-    "embeddingsService = AzureTextEmbedding(\n",
-    "    deployment_name=embedding_name,\n",
-    "    endpoint=openai_api_base,\n",
-    "    api_key=openai_api_key,\n",
-    "    logger=my_logger\n",
-    ")\n",
-    "kernel.add_text_embedding_generation_service(\n",
-    "    \"ada002\",\n",
-    "    embeddingsService\n",
-    ")\n",
-    "\n",
-    "# Ask the question\n",
-    "question = \"List the movies about ships on the water.\"\n",
-    "\n",
-    "# Create a prompt template with variables, note the double curly braces with dollar sign for the variables\n",
-    "sk_prompt = \"\"\"\n",
-    "Question: {{$original_question}}\n",
-    "\n",
-    "Do not use any other data.\n",
-    "Only use the movie data below when responding.\n",
-    "{{$search_results}}\n",
-    "\"\"\"\n",
-    "# Create the PromptTemplateConfig\n",
-    "prompt_config = PromptTemplateConfig(\n",
-    "    description=\"Gets the intent of the user.\",\n",
-    "    type=\"completion\",\n",
-    "    completion=PromptTemplateConfig.CompletionConfig(\n",
-    "        temperature=0.1,\n",
-    "        top_p=0.5,\n",
-    "        presence_penalty=0.0,\n",
-    "        frequency_penalty=0.0,\n",
-    "        max_tokens=500,\n",
-    "        # number_of_responses=1,\n",
-    "        # stop_sequences=None,\n",
-    "        # token_selection_biases=None,\n",
-    "        # chat_system_prompt=None\n",
-    "    ),\n",
-    "    input=PromptTemplateConfig.InputConfig(\n",
-    "        parameters=[\n",
-    "            PromptTemplateConfig.InputParameter(\n",
-    "                name=\"original_question\",\n",
-    "                description=\"The user's request.\",\n",
-    "                default_value=\"\"\n",
-    "            ),\n",
-    "            PromptTemplateConfig.InputParameter(\n",
-    "                name=\"search_results\",\n",
-    "                description=\"Vector Search results from Azure Cognitive Search.\",\n",
-    "                default_value=\"\"\n",
-    "            )\n",
-    "        ]\n",
-    "    ),\n",
-    ")\n",
-    "# Create the SemanticFunctionConfig object\n",
-    "prompt_template = PromptTemplate(\n",
-    "    template=sk_prompt,\n",
-    "    template_engine=kernel.prompt_template_engine,\n",
-    "    prompt_config=prompt_config,\n",
-    ")\n",
-    "function_config = SemanticFunctionConfig(prompt_config, prompt_template)\n",
-    "# Register the Semantic Function with SK\n",
-    "get_intent = kernel.register_semantic_function(\n",
-    "    skill_name=\"CustomPlugin\",\n",
-    "    function_name=\"GetIntent\",\n",
-    "    function_config=function_config,\n",
-    ")\n",
-    "\n",
-    "# Get Embedding for the original question\n",
-    "question_embedded = await embeddingsService.generate_embeddings_async(question)\n",
-    "\n",
-    "# Search Vector Store\n",
-    "search_client = SearchClient(\n",
-    "    acs_endpoint_name,\n",
-    "    acs_index_name,\n",
-    "    AzureKeyCredential(acs_api_key)\n",
-    ")\n",
-    "vector = Vector(\n",
-    "    value=question_embedded[0],\n",
-    "    k=5,\n",
-    "    fields=\"content_vector\"\n",
-    ")\n",
-    "results = list(search_client.search(\n",
-    "    search_text=\"\",\n",
-    "    include_total_count=True,\n",
-    "    vectors=[vector],\n",
-    "    select=[\"content\"],\n",
-    "))\n",
-    "\n",
-    "# Build the Prompt and Execute against the Azure OpenAI to get the completion\n",
-    "# Initialize the prompt variables\n",
-    "variables = sk.ContextVariables()\n",
-    "variables[\"original_question\"] = question\n",
-    "variables[\"search_results\"] = str(results)\n",
-    "# Use SK Chaining to Invoke Semantic Function\n",
-    "completion = await kernel.run_async(\n",
-    "    get_intent,\n",
-    "    input_vars=variables\n",
-    ")\n",
-    "print(completion)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Next Section\n",
-    "\n",
-    "📣 [Deploy AI](../../04-deploy-ai/README.md)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.11.5"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/labs/03-orchestration/README.md b/labs/03-orchestration/README.md
index b6505f6..ac53a9a 100644
--- a/labs/03-orchestration/README.md
+++ b/labs/03-orchestration/README.md
@@ -24,8 +24,8 @@ In this lab, we'll walk through using an open source vector store called Qdrant.
 
 ## 04-ACS
 
-[Azure Cognitive Search + Semantic Kernel C#](04-ACS/acs-sk-csharp.ipynb)
-[Azure Cognitive Search + Semantic Kernel Python](04-ACS/acs-sk-python.ipynb)
-[Azure Cognitive Search + Langchain Python](04-ACS/acs-lc-python.ipynb)
+[Azure AI Search + Semantic Kernel C#](04-ACS/acs-sk-csharp.ipynb)
+[Azure AI Search + Semantic Kernel Python](04-ACS/acs-sk-python.ipynb)
+[Azure AI Search + Langchain Python](04-ACS/acs-lc-python.ipynb)
 
-In this lab, we'll walk through using one of Azure's vector stores, **Azure Cognitive Search**.
+In this lab, we'll walk through using one of Azure's vector stores, **Azure AI Search**.
diff --git a/labs/99-removed/acs-sk-python.ipynb b/labs/99-removed/acs-sk-python.ipynb
new file mode 100644
index 0000000..42bac51
--- /dev/null
+++ b/labs/99-removed/acs-sk-python.ipynb
@@ -0,0 +1,736 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Temporarily Removed**\n",
+    "\n",
+    "Original location:\n",
+    "intro-to-intelligent-apps/labs/03-orchestration/04-ACS\n",
+    "\n",
+    "The Semantic Kernel python libraries are undergoing significant change to align them with the functionality of the .NET libraries.\n",
+    "\n",
+    "As at 22nd January 2024, the azure-search-documents package latest version is 11.4.0. The code in the first half of this lab - i.e. the Azure AI Search parts - have been updated to work with this version of the package and are fully functional.\n",
+    "\n",
+    "However, Semantic Kernel currently has a dependency on azure-search-documents 11.4.0b9. If this version is not used, the second part of this lab (Bringing it all together) will not work. However, if you use 11.4.0b9, the first part of the lab will not work.\n",
+    "\n",
+    "Also, since this lab was first created, the semantic-kernel package has been updated so the code in the second part of this lab will not work with the latest version of the package anyway.\n",
+    "\n",
+    "This lab will be reintroduced once the Semantic Kernel python libraries appear to have stabilised."
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 04 - AI Orchestration with Azure AI Search\n",
+    "**(Semantic Kernel / Python version)**\n",
+    "\n",
+    "In this lab, we will do a deeper dive into using Azure AI Search as a vector store, the different search methods it supports and how you can use it as part of the Retrieval Augmented Generation (RAG) pattern for working with large language models."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create an Azure AI Search Vector Store in Azure\n",
+    "\n",
+    "First, we will create an Azure AI Search service in Azure. The following are command line instructions and require the Azure CLI to be installed.\n",
+    "\n",
+    "**NOTE:** Before running the commands, replace the **`<INITIALS>`** with your own initials or some random characters, as we need to provide a unique name for the Azure AI Search service."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RESOURCE_GROUP=\"azure-ai-search-rg\"\n",
+    "LOCATION=\"westeurope\"\n",
+    "NAME=\"ai-vectorstore-<INITIALS>\"\n",
+    "!az group create --name $RESOURCE_GROUP --location $LOCATION\n",
+    "!az search service create -g $RESOURCE_GROUP -n $NAME -l $LOCATION --sku Basic --partition-count 1 --replica-count 1"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Next, we need to find and update the following values in the `.env` file with the Azure AI Search **name**, **endpoint** and **admin key** values, which you can get from the Azure portal. You also need to provide an **index name** value. The index will be created during this lab, so you can use any name you like.\n",
+    "\n",
+    "```\n",
+    "AZURE_AI_SEARCH_SERVICE_NAME = \"<YOUR AZURE AI SEARCH SERVICE NAME - e.g. ai-vectorstore-xyz>\"\n",
+    "AZURE_AI_SEARCH_ENDPOINT = \"<YOUR AZURE AI SEARCH ENDPOINT URL - e.g. https://ai-vectorstore-xyz.search.windows.net\"\n",
+    "AZURE_AI_SEARCH_INDEX_NAME = \"<YOUR AZURE AI SEARCH INDEX NAME - e.g. ai-search-index>\"\n",
+    "AZURE_AI_SEARCH_API_KEY = \"<YOUR AZURE AI SEARCH ADMIN API KEY - e.g. get this value from the Azure portal>\"\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load environment variable values\n",
+    "As with previous labs, we'll use the values from the `.env` file in the root of this repository."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "# Load environment variables\n",
+    "if load_dotenv():\n",
+    "    print(\"This lab exercise will use the following values:\")\n",
+    "    print(\"Azure OpenAI Endpoint: \" + os.getenv(\"AZURE_OPENAI_ENDPOINT\"))\n",
+    "    print(\"Azure AI Search: \" + os.getenv(\"AZURE_AI_SEARCH_SERVICE_NAME\"))\n",
+    "else: \n",
+    "    print(\"No file .env found\")\n",
+    "\n",
+    "azure_openai_api_key = os.getenv(\"AZURE_OPENAI_API_KEY\")\n",
+    "azure_openai_endpoint = os.getenv(\"AZURE_OPENAI_ENDPOINT\")\n",
+    "openai_api_version = os.getenv(\"OPENAI_API_VERSION\")\n",
+    "azure_openai_completion_deployment_name = os.getenv(\"AZURE_OPENAI_COMPLETION_DEPLOYMENT_NAME\")\n",
+    "azure_openai_embedding_deployment_name = os.getenv(\"AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME\")\n",
+    "azure_ai_search_name = os.getenv(\"AZURE_AI_SEARCH_SERVICE_NAME\")\n",
+    "azure_ai_search_endpoint = os.getenv(\"AZURE_AI_SEARCH_ENDPOINT\")\n",
+    "azure_ai_search_index_name = os.getenv(\"AZURE_AI_SEARCH_INDEX_NAME\")\n",
+    "azure_ai_search_api_key = os.getenv(\"AZURE_AI_SEARCH_API_KEY\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First, we will load the data from the movies.csv file and then extract a subset to load into the Azure AI Search index. We do this to help avoid the Azure OpenAI embedding limits and long loading times when inserting data into the index. We use a Langchain document loader to do this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.document_loaders.csv_loader import CSVLoader\n",
+    "\n",
+    "loader = CSVLoader(file_path='./movies.csv', source_column='original_title', encoding='utf-8', csv_args={'delimiter':',', 'fieldnames': ['id', 'original_language', 'original_title', 'popularity', 'release_date', 'vote_average', 'vote_count', 'genre', 'overview', 'revenue', 'runtime', 'tagline']})\n",
+    "data = loader.load()\n",
+    "\n",
+    "# Rather than load all 500 movies into Azure AI search, we will use a\n",
+    "# smaller subset of movie data to make things quicker. The more movies you load,\n",
+    "# the more time it will take for embeddings to be generated.\n",
+    "\n",
+    "data = data[1:51]\n",
+    "print('Loaded %s movies.' % len(data))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "During this lab, we will need to work with embeddings. We use embeddings to create a vector representation of a piece of text. We will need to create embeddings for the documents we want to store in our Azure AI Search index and also for the queries we want to use to search the index. We will create an Azure OpenAI client to do this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings import AzureOpenAIEmbeddings\n",
+    "\n",
+    "azure_openai_embeddings = AzureOpenAIEmbeddings(\n",
+    "    azure_deployment = os.getenv(\"AZURE_OPENAI_EMBEDDINGS_DEPLOYMENT_NAME\")\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create an Azure AI Search index and load movie data\n",
+    "\n",
+    "Next, we'll step through the process of configuring an Azure AI Search index to store our movie data and then loading the data into the index. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from azure.core.credentials import AzureKeyCredential\n",
+    "from azure.search.documents import SearchClient\n",
+    "from azure.search.documents.indexes import SearchIndexClient\n",
+    "from azure.search.documents.indexes.models import (\n",
+    "    VectorSearch,\n",
+    "    VectorSearchProfile,\n",
+    "    HnswAlgorithmConfiguration,\n",
+    "    SemanticPrioritizedFields,\n",
+    "    SemanticSearch,\n",
+    "    SemanticField,\n",
+    "    SemanticConfiguration,\n",
+    "    SimpleField,\n",
+    "    SearchableField,\n",
+    "    SearchField,\n",
+    "    SearchFieldDataType,\n",
+    "    SearchIndex\n",
+    ")\n",
+    "from azure.search.documents.models import (\n",
+    "    VectorizedQuery\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "When configuring an Azure AI Search index, we need to specify the fields we want to store in the index and the data types for each field. These match the fields in the movie data, containing values such as the movie title, genre, year of release and so on.\n",
+    "\n",
+    "To use Azure AI Search as a vector store, we will also need to define a field to hold the vector representaion of the movie data. We indicate to Azure AI Search that this field will contain vector data by providing details of the vector dimensions and a profile. We'll also define the vector search configuration and profile with default values.\n",
+    "\n",
+    "**NOTE:** It is possible just to use Azure AI Search as a vector store only, in which case we probably wouldn't need to define all of the index fields below. However, in this lab, we're also going to demonstrate Hybrid Search, a feature which makes use of both traditional keyword based search in combination with vector search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fields = [\n",
+    "    SimpleField(name=\"id\", type=SearchFieldDataType.String, key=True, sortable=True, filterable=True, facetable=True),\n",
+    "    SearchableField(name=\"title\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"overview\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"genre\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"tagline\", type=SearchFieldDataType.String),\n",
+    "    SearchableField(name=\"release_date\", type=SearchFieldDataType.DateTimeOffset, sortable=True),\n",
+    "    SearchableField(name=\"popularity\", type=SearchFieldDataType.Double, sortable=True),\n",
+    "    SearchableField(name=\"vote_average\", type=SearchFieldDataType.Double, sortable=True),\n",
+    "    SearchableField(name=\"vote_count\", type=SearchFieldDataType.Int32, sortable=True),\n",
+    "    SearchableField(name=\"runtime\", type=SearchFieldDataType.Int32, sortable=True),\n",
+    "    SearchableField(name=\"revenue\", type=SearchFieldDataType.Int64, sortable=True),\n",
+    "    SearchableField(name=\"original_language\", type=SearchFieldDataType.String),\n",
+    "    SearchField(name=\"vector\", type=SearchFieldDataType.Collection(SearchFieldDataType.Single), searchable=True, vector_search_dimensions=1536, vector_search_profile_name=\"movies-vector-profile\"),\n",
+    "]\n",
+    "\n",
+    "vector_search = VectorSearch(\n",
+    "    profiles=[VectorSearchProfile(name=\"movies-vector-profile\", algorithm_configuration_name=\"movies-vector-config\")],\n",
+    "    algorithms=[HnswAlgorithmConfiguration(name=\"movies-vector-config\")],\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We're going to be using Semantic Ranking, a feature of Azure AI Search that improves search results by using language understanding to rerank the search results. We provide a Semantic Search Configuration to help the ranking model understand the movie data, by telling it which fields contain the movie title, which fields contain keywords and which fields contain general free text content."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "semantic_config = SemanticConfiguration(\n",
+    "    name=\"movies-semantic-config\",\n",
+    "    prioritized_fields=SemanticPrioritizedFields(\n",
+    "        title_field=SemanticField(field_name=\"title\"),\n",
+    "        keywords_fields=[SemanticField(field_name=\"genre\")],\n",
+    "        content_fields=[SemanticField(field_name=\"title\"),\n",
+    "                        SemanticField(field_name=\"overview\"),\n",
+    "                        SemanticField(field_name=\"tagline\"),\n",
+    "                        SemanticField(field_name=\"genre\"),\n",
+    "                        SemanticField(field_name=\"release_date\"),\n",
+    "                        SemanticField(field_name=\"popularity\"),\n",
+    "                        SemanticField(field_name=\"vote_average\"),\n",
+    "                        SemanticField(field_name=\"vote_count\"),\n",
+    "                        SemanticField(field_name=\"runtime\"),\n",
+    "                        SemanticField(field_name=\"revenue\"),\n",
+    "                        SemanticField(field_name=\"original_language\")],\n",
+    "    )\n",
+    ")\n",
+    "\n",
+    "semantic_search = SemanticSearch(configurations=[semantic_config])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Finally, we'll go ahead and create the index by creating an instance of the `SearchIndex` class and adding the keyword and vectors fields and the semantic search profile."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create the search index with the desired vector search and semantic configurations\n",
+    "index = SearchIndex(\n",
+    "    name=azure_ai_search_index_name,\n",
+    "    fields=fields,\n",
+    "    vector_search=vector_search,\n",
+    "    semantic_search=semantic_search\n",
+    ")\n",
+    "\n",
+    "index_client = SearchIndexClient(\n",
+    "    azure_ai_search_endpoint,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
+    ")\n",
+    "\n",
+    "result = index_client.create_or_update_index(index)\n",
+    "\n",
+    "print(f'Index {result.name} created.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The index is now ready, so next we need to prepare the movie data to load into the index.\n",
+    "\n",
+    "**NOTE**: During this phase, we send the data for each movie to an Azure OpenAI embeddings model to create the vector data. This may take some time due to rate limiting in the API."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Loop through all of the movies and create a new item for each one.\n",
+    "\n",
+    "items = []\n",
+    "for movie in data:\n",
+    "    content = movie.page_content\n",
+    "    fields = movie.page_content.split('\\n')\n",
+    "    movieId = (fields[0].split(': ')[1])[:-2]\n",
+    "    movieTitle = (fields[2].split(': ')[1])\n",
+    "    movieOverview = (fields[8].split(': ')[1])\n",
+    "    movieGenre = (fields[7].split(': ')[1])[1:-1]\n",
+    "    movieTagline = (fields[11].split(': ')[1])\n",
+    "    movieReleaseDate = (fields[4].split(': ')[1])\n",
+    "    moviePopularity = (fields[3].split(': ')[1])\n",
+    "    movieVoteAverage = (fields[5].split(': ')[1])\n",
+    "    movieVoteCount = (fields[6].split(': ')[1])\n",
+    "    movieRuntime = (fields[10].split(': ')[1])\n",
+    "    movieRevenue = (fields[9].split(': ')[1])\n",
+    "    movieOriginalLanguage = (fields[1].split(': ')[1])\n",
+    "\n",
+    "    items.append(dict([\n",
+    "        (\"id\", movieId), \n",
+    "        (\"title\", movieTitle),\n",
+    "        (\"overview\", movieOverview),\n",
+    "        (\"genre\", movieGenre),\n",
+    "        (\"tagline\", movieTagline),\n",
+    "        (\"release_date\", movieReleaseDate),\n",
+    "        (\"popularity\", moviePopularity),\n",
+    "        (\"vote_average\", movieVoteAverage),\n",
+    "        (\"vote_count\", movieVoteCount),\n",
+    "        (\"runtime\", movieRuntime),\n",
+    "        (\"revenue\", movieRevenue),\n",
+    "        (\"original_language\", movieOriginalLanguage),\n",
+    "        (\"vector\", azure_openai_embeddings.embed_query(content))\n",
+    "    ]))\n",
+    "\n",
+    "    print(f\"Movie {movieTitle} added.\")\n",
+    "\n",
+    "print(f\"New items structure with embeddings created for {len(items)} movies.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can write out the contents of one of the documents to see what it looks like. You can see that it contains the movie data at the top and then a long array containing the vector data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(items[0])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we have the movie data stored in the correct format, so let's load it into the Azure AI Search index we created earlier."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from azure.search.documents import SearchClient\n",
+    "\n",
+    "search_client = SearchClient(\n",
+    "    azure_ai_search_endpoint,\n",
+    "    azure_ai_search_index_name,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
+    ")\n",
+    "\n",
+    "result = search_client.upload_documents(items)\n",
+    "\n",
+    "print(f\"Successfully loaded {len(data)} movies into Azure AI Search index.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vector store searching using Azure AI Search\n",
+    "\n",
+    "We've loaded the movies into Azure AI Search, so now let's experiment with some of the different types of searches you can perform.\n",
+    "\n",
+    "First we'll just perform a simple keyword search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"hero\"\n",
+    "\n",
+    "results = list(search_client.search(\n",
+    "    search_text=query,\n",
+    "    query_type=\"simple\",\n",
+    "    include_total_count=True,\n",
+    "    top=5\n",
+    "))\n",
+    "\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
+    "    print(\"----------\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We get some results, but they're not necessarily movies about heroes. It could be that there is some text in the index for these results that relates to the word \"hero\". For example, the description might mention \"heroic deeds\" or something similar.\n",
+    "\n",
+    "Let's now try the same again, but this time we'll ask a question instead of just searching for a keyword."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What are the best movies about superheroes?\"\n",
+    "\n",
+    "results = list(search_client.search(\n",
+    "    search_text=query,\n",
+    "    query_type=\"simple\",\n",
+    "    include_total_count=True,\n",
+    "    top=5\n",
+    "))\n",
+    "\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
+    "    print(\"----------\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As before, you will likely get mixed results. Some of the movies returned could be about heroes, but others may not be. This is because the search is still based on keywords.\n",
+    "\n",
+    "Next, let's try a vector search."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What are the best movies about superheroes?\"\n",
+    "\n",
+    "vector = VectorizedQuery(vector=azure_openai_embeddings.embed_query(query), k_nearest_neighbors=5, fields=\"vector\")\n",
+    "\n",
+    "# Note the `None` value for the `search_text` parameter. This is because we're not sending the query text to Azure AI Search. We're sending the embedded version of the query text instead via the `vector_queries` parameter.\n",
+    "\n",
+    "results = list(search_client.search(\n",
+    "    search_text=None,\n",
+    "    query_type=\"semantic\",\n",
+    "    semantic_configuration_name=\"movies-semantic-config\",\n",
+    "    vector_queries=[vector],\n",
+    "    select=[\"title\", \"genre\"],\n",
+    "    top=5\n",
+    "))\n",
+    "\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
+    "    print(\"----------\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "It's likely that the raw vector search didn't return exactly what you were expecting. You were probably expecting a list of superhero movies, but now we're getting a list of movies that are **similar** to the vector we provided. Some of these may be hero movies, but others may not be. The vector search is returning the nearest neighbours to the vector we provided, so it's possible that at least one of the results is a superhero movie, and the others are similar to that movie in some way.\n",
+    "\n",
+    "So, both the keyword search and the vector search have their limitations. The keyword search is limited to the keywords in the index, so it's possible that we might miss some movies that are about heroes. The vector search is limited to returning the nearest neighbours to the vector we provide, so it's possible that we might get some movies that are not about heroes.\n",
+    "\n",
+    "## Hybrid search using Azure AI Search\n",
+    "\n",
+    "To overcome the limitations of both keyword search and vector search, we can use a combination of both. This is known as Hybrid Search. Let's run the same query again, but this time we'll use Hybrid Search.\n",
+    "\n",
+    "The only significant difference is that this time we will submit both the original query text and the embedding vector to Azure AI Search. Azure AI Search will then use both the query text and the vector to perform the search and combine the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"What are the best movies about superheroes?\"\n",
+    "\n",
+    "vector = VectorizedQuery(vector=azure_openai_embeddings.embed_query(query), k_nearest_neighbors=5, fields=\"vector\")\n",
+    "\n",
+    "# Note the `None` value for the `search_text` parameter. This is because we're not sending the query text to Azure AI Search. We're sending the embedded version of the query text instead via the `vector_queries` parameter.\n",
+    "\n",
+    "results = list(search_client.search(\n",
+    "    search_text=query,\n",
+    "    query_type=\"semantic\",\n",
+    "    semantic_configuration_name=\"movies-semantic-config\",\n",
+    "    vector_queries=[vector],\n",
+    "    select=[\"title\", \"genre\"],\n",
+    "    top=5\n",
+    "))\n",
+    "\n",
+    "for result in results:\n",
+    "    print(\"Movie: {}\".format(result[\"title\"]))\n",
+    "    print(\"Genre: {}\".format(result[\"genre\"]))\n",
+    "    print(\"Score: {}\".format(result[\"@search.score\"]))\n",
+    "    print(\"Reranked score: {}\".format(result[\"@search.reranker_score\"]))\n",
+    "    print(\"----------\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hopefully, you'll now see a much better set of results. Performing a hybrid search has allowed us to combine the benefits of both keyword search and vector search. But also, Azure AI Search performs a further step when using hybrid search. It makes use of a Semantic Ranker to further improve the search results. The Semantic Ranker uses a language understanding model to understand the query text and the documents in the index and then uses this information to rerank the search results. So, after performing the keyword and vector search, Azure AI Search will then use the Semantic Ranker to re-order the search results based on the context of the original query.\n",
+    "\n",
+    "In the results above, you can see a `Reranked Score`. This is the score that has been calculated by the Semantic Ranker. The `Score` is the score calculated by the keyword and vector search. You'll note that the results are returned in the order determined by the reranked score."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bringing it All Together with Retrieval Augmented Generation (RAG) + Semantic Kernel (SK)\n",
+    "\n",
+    "Now that we have our Vector Store setup and data loaded, we are now ready to implement the RAG pattern using AI Orchestration. At a high-level, the following steps are required:\n",
+    "1. Ask the question\n",
+    "2. Create Prompt Template with inputs\n",
+    "3. Get Embedding representation of inputted question\n",
+    "4. Use embedded version of the question to search Azure Cognitive Search (ie. The Vector Store)\n",
+    "5. Inject the results of the search into the Prompt Template & Execute the Prompt to get the completion"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Implement RAG using Semantic Kernel (SK)\n",
+    "import asyncio\n",
+    "\n",
+    "import semantic_kernel as sk\n",
+    "from semantic_kernel.connectors.ai.open_ai import (\n",
+    "    AzureChatCompletion,\n",
+    "    AzureTextEmbedding,\n",
+    ")\n",
+    "from semantic_kernel.connectors.memory.azure_cognitive_search import (\n",
+    "    AzureCognitiveSearchMemoryStore,\n",
+    ")\n",
+    "from semantic_kernel.semantic_functions.prompt_template import PromptTemplate\n",
+    "from semantic_kernel.semantic_functions.prompt_template_config import PromptTemplateConfig\n",
+    "from semantic_kernel.semantic_functions.semantic_function_config import SemanticFunctionConfig\n",
+    "from azure.search.documents.models import Vector\n",
+    "from azure.search.documents import SearchClient\n",
+    "from azure.search.documents.indexes import SearchIndexClient\n",
+    "from azure.search.documents.indexes.models import (\n",
+    "    SearchIndex,\n",
+    "    SearchField,\n",
+    "    SearchFieldDataType,\n",
+    "    SimpleField,\n",
+    "    SearchableField,\n",
+    "    SearchIndex,\n",
+    "    SemanticConfiguration,\n",
+    "    PrioritizedFields,\n",
+    "    SemanticField,\n",
+    "    SearchField,\n",
+    "    SemanticSettings,\n",
+    "    VectorSearch,\n",
+    "    HnswVectorSearchAlgorithmConfiguration,\n",
+    "    )\n",
+    "from azure.core.credentials import AzureKeyCredential\n",
+    "\n",
+    "# Setup Semantic Kernel\n",
+    "my_logger = sk.NullLogger()\n",
+    "kernel = sk.Kernel(\n",
+    "    log=my_logger\n",
+    ")\n",
+    "\n",
+    "# Add Chat Service to SK\n",
+    "kernel.add_chat_service(\n",
+    "    \"gpt35turbo\",\n",
+    "    AzureChatCompletion(\n",
+    "        deployment_name=azure_openai_completion_deployment_name,\n",
+    "        endpoint=azure_openai_endpoint,\n",
+    "        api_key=azure_openai_api_key,\n",
+    "        logger=my_logger\n",
+    "    )\n",
+    ")\n",
+    "# Add Text Embeddings Service to SK\n",
+    "embeddingsService = AzureTextEmbedding(\n",
+    "    deployment_name=azure_openai_embedding_deployment_name,\n",
+    "    endpoint=azure_openai_endpoint,\n",
+    "    api_key=azure_openai_api_key,\n",
+    "    logger=my_logger\n",
+    ")\n",
+    "kernel.add_text_embedding_generation_service(\n",
+    "    \"ada002\",\n",
+    "    embeddingsService\n",
+    ")\n",
+    "\n",
+    "# Ask the question\n",
+    "question = \"List the movies about ships on the water.\"\n",
+    "\n",
+    "# Create a prompt template with variables, note the double curly braces with dollar sign for the variables\n",
+    "sk_prompt = \"\"\"\n",
+    "Question: {{$original_question}}\n",
+    "\n",
+    "Do not use any other data.\n",
+    "Only use the movie data below when responding.\n",
+    "{{$search_results}}\n",
+    "\"\"\"\n",
+    "# Create the PromptTemplateConfig\n",
+    "prompt_config = PromptTemplateConfig(\n",
+    "    description=\"Gets the intent of the user.\",\n",
+    "    type=\"completion\",\n",
+    "    input=PromptTemplateConfig.InputConfig(\n",
+    "        parameters=[\n",
+    "            PromptTemplateConfig.InputParameter(\n",
+    "                name=\"original_question\",\n",
+    "                description=\"The user's request.\",\n",
+    "                default_value=\"\"\n",
+    "            ),\n",
+    "            PromptTemplateConfig.InputParameter(\n",
+    "                name=\"search_results\",\n",
+    "                description=\"Vector Search results from Azure Cognitive Search.\",\n",
+    "                default_value=\"\"\n",
+    "            )\n",
+    "        ]\n",
+    "    ),\n",
+    ")\n",
+    "# Create the SemanticFunctionConfig object\n",
+    "prompt_template = PromptTemplate(\n",
+    "    template=sk_prompt,\n",
+    "    template_engine=kernel.prompt_template_engine,\n",
+    "    prompt_config=prompt_config,\n",
+    ")\n",
+    "function_config = SemanticFunctionConfig(prompt_config, prompt_template)\n",
+    "# Register the Semantic Function with SK\n",
+    "get_intent = kernel.register_semantic_function(\n",
+    "    skill_name=\"CustomPlugin\",\n",
+    "    function_name=\"GetIntent\",\n",
+    "    function_config=function_config,\n",
+    ")\n",
+    "\n",
+    "# Get Embedding for the original question\n",
+    "question_embedded = await embeddingsService.generate_embeddings_async(question)\n",
+    "\n",
+    "# Search Vector Store\n",
+    "search_client = SearchClient(\n",
+    "    azure_ai_search_endpoint,\n",
+    "    azure_ai_search_index_name,\n",
+    "    AzureKeyCredential(azure_ai_search_api_key)\n",
+    ")\n",
+    "vector = Vector(\n",
+    "    value=question_embedded[0],\n",
+    "    k=5,\n",
+    "    fields=\"vector\"\n",
+    ")\n",
+    "results = list(search_client.search(\n",
+    "    search_text=\"\",\n",
+    "    include_total_count=True,\n",
+    "    vectors=[vector],\n",
+    "    select=[\"title\",\"genre\",\"overview\",\"tagline\",\"release_date\",\"popularity\",\"vote_average\",\"vote_count\",\"runtime\",\"revenue\",\"original_language\"],\n",
+    "    ))\n",
+    "\n",
+    "# Build the Prompt and Execute against the Azure OpenAI to get the completion\n",
+    "# Initialize the prompt variables\n",
+    "variables = sk.ContextVariables()\n",
+    "variables[\"original_question\"] = question\n",
+    "variables[\"search_results\"] = str(results)\n",
+    "# Use SK Chaining to Invoke Semantic Function\n",
+    "completion = await kernel.run_async(\n",
+    "    get_intent,\n",
+    "    input_vars=variables\n",
+    ")\n",
+    "print(completion)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Next Section\n",
+    "\n",
+    "📣 [Deploy AI](../../04-deploy-ai/README.md)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "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.11.6"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/requirements.txt b/requirements.txt
index ae108bc..05eb941 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,14 +1,15 @@
-azure-core==1.29.3
-azure-identity==1.14.0
-azure-search-documents==11.4.0b8
-semantic-kernel==0.3.12.dev0
-openai==0.27.9
-langchain==0.0.329
-tiktoken==0.4.0
+azure-core==1.29.7
+azure-identity==1.15.0
+azure-search-documents==11.4.0
+semantic-kernel==0.4.5.dev0
+openai==1.9.0
+langchain==0.1.1
+langchain-openai==0.0.3
+tiktoken==0.5.2
 python-dotenv==1.0.0
 requests==2.31.0
-unstructured==0.10.5
-markdown==3.4.4
-qdrant-client==1.4.0
-chromadb==0.4.6
-yfinance==0.2.32
\ No newline at end of file
+unstructured==0.12.2
+markdown==3.5.2
+qdrant-client==1.7.1
+chromadb==0.4.22
+yfinance==0.2.36
\ No newline at end of file