WK1/elastic_search_llm_wk1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d7fc721f-43a1-4fe9-bd85-aa9236ef92e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import openai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "40e4bb91-64d9-4b62-ada4-f397aab94e0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openai import OpenAI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "afcf5397-4023-425a-8d28-047da0818023",
   "metadata": {},
   "outputs": [],
   "source": [
    "client = OpenAI()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac1ffdf6-324e-46b2-a142-34fad9890c25",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b58e5e20-557c-4f4d-95cf-986c5debc8bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "#from dotenv import load_dotenv, find_dotenv\n",
    "#_ = load_dotenv(find_dotenv())\n",
    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "#openai.api_key="
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a3dbd8e4-6c8d-4e5a-a48f-94cf5399c2e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "openai.api_key=api_key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d14766d9-8230-4f15-b1d3-050139f66b3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "response = client.chat.completions.create(model='gpt-4o', messages=[{\"role\":\"user\", \"content\":\"is it late to join the course\"}])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9554acea-461c-4248-8c0b-6da87e8741e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"The answer to whether it's late to join a course depends on a variety of factors:\\n\\n1. **Course Start Date**: If the course has just started or is still in the early weeks, it might be possible to catch up with some extra effort.\\n2. **Course Duration**: For shorter courses, joining late might be more challenging compared to longer courses where there is more time to catch up.\\n3. **Instructor Policies**: Some instructors are flexible and may allow late enrollments with additional support, while others may have strict deadlines.\\n4. **Course Format**: Online and self-paced courses might offer more flexibility for late joiners compared to in-person or synchronous online courses.\\n5. **Prerequisites and Initial Content**: If there are foundational concepts covered at the beginning of the course, missing these might make it difficult to understand later material.\\n6. **Resources Availability**: Check if recorded lectures, notes, and other materials are available to review the missed content.\\n\\nTo find out if it's too late, consider reaching out directly to the course instructor or the institution offering the course to discuss your specific situation. They can provide the most accurate advice and potential solutions for catching up if late enrollment is possible.\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response.choices[0].message.content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ccf82921-1d2c-45ce-b9a6-72bde7b0bc53",
   "metadata": {},
   "outputs": [],
   "source": [
    "import minsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "93d160e5-661c-4837-98a6-eac092585338",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "c7223655-5b40-422d-a3b8-cafacbb60130",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open ('documents.json', 'rt') as f_in:\n",
    "    doc_raw = json.load(f_in)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fd21592c-615f-4528-a3a2-b8b4432d8c65",
   "metadata": {},
   "outputs": [],
   "source": [
    "documents = []\n",
    "for course in doc_raw:\n",
    "    for doc in course['documents']:\n",
    "        doc['course'] = course['course']\n",
    "        documents.append(doc)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b4244659-8278-4c63-9d0f-07ec43632c88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'text': \"The purpose of this document is to capture frequently asked technical questions\\nThe exact day and hour of the course will be 15th Jan 2024 at 17h00. The course will start with the first  “Office Hours'' live.1\\nSubscribe to course public Google Calendar (it works from Desktop only).\\nRegister before the course starts using this link.\\nJoin the course Telegram channel with announcements.\\nDon’t forget to register in DataTalks.Club's Slack and join the channel.\",\n",
       " 'section': 'General course-related questions',\n",
       " 'question': 'Course - When will the course start?',\n",
       " 'course': 'data-engineering-zoomcamp'}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "documents[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "93c2d427-0397-4c42-bea2-e5beeea14454",
   "metadata": {},
   "outputs": [],
   "source": [
    "index = minsearch.Index(\n",
    "    text_fields=[\"question\", \"text\", \"section\"],\n",
    "    keyword_fields=[\"course\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "63dc5f25-604f-4fbd-b107-b019e30e8cda",
   "metadata": {},
   "outputs": [],
   "source": [
    "#siilar to select * where course = ''data-engineering-zoomcamp''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "9af8551a-4c1b-4e8e-96aa-afe6d5c0371b",
   "metadata": {},
   "outputs": [],
   "source": [
    "question='the course has already started, can I still enroll'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "74da0d3c-e14d-493f-8053-5a6e15df7312",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<minsearch.Index at 0x7addf3764ee0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#fit the serach withthe documents\n",
    "index.fit(documents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "73b95ef1-9788-4a78-abd2-b96e726aacd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "boost = {'question':3.0, 'section':.5}\n",
    "knowledge_results = index.search(query=question, filter_dict={'course':'data-engineering-zoomcamp'},\n",
    "                       boost_dict=boost, num_results=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "47a1a288-dad7-4410-ac9c-adb77706551b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': \"Yes, even if you don't register, you're still eligible to submit the homeworks.\\nBe aware, however, that there will be deadlines for turning in the final projects. So don't leave everything for the last minute.\",\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I still join the course after the start date?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'Yes, we will keep all the materials after the course finishes, so you can follow the course at your own pace after it finishes.\\nYou can also continue looking at the homeworks and continue preparing for the next cohort. I guess you can also start working on your final capstone project.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I follow the course after it finishes?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': \"The purpose of this document is to capture frequently asked technical questions\\nThe exact day and hour of the course will be 15th Jan 2024 at 17h00. The course will start with the first  “Office Hours'' live.1\\nSubscribe to course public Google Calendar (it works from Desktop only).\\nRegister before the course starts using this link.\\nJoin the course Telegram channel with announcements.\\nDon’t forget to register in DataTalks.Club's Slack and join the channel.\",\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - When will the course start?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'You can start by installing and setting up all the dependencies and requirements:\\nGoogle cloud account\\nGoogle Cloud SDK\\nPython 3 (installed with Anaconda)\\nTerraform\\nGit\\nLook over the prerequisites and syllabus to see if you are comfortable with these subjects.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - What can I do before the course starts?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'Yes, the slack channel remains open and you can ask questions there. But always sDocker containers exit code w search the channel first and second, check the FAQ (this document), most likely all your questions are already answered here.\\nYou can also tag the bot @ZoomcampQABot to help you conduct the search, but don’t rely on its answers 100%, it is pretty good though.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I get support if I take the course in the self-paced mode?',\n",
       "  'course': 'data-engineering-zoomcamp'}]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d4a481e2-61b8-4437-b15d-5239c021d91a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': \"Yes, even if you don't register, you're still eligible to submit the homeworks.\\nBe aware, however, that there will be deadlines for turning in the final projects. So don't leave everything for the last minute.\",\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I still join the course after the start date?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'Yes, we will keep all the materials after the course finishes, so you can follow the course at your own pace after it finishes.\\nYou can also continue looking at the homeworks and continue preparing for the next cohort. I guess you can also start working on your final capstone project.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I follow the course after it finishes?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': \"The purpose of this document is to capture frequently asked technical questions\\nThe exact day and hour of the course will be 15th Jan 2024 at 17h00. The course will start with the first  “Office Hours'' live.1\\nSubscribe to course public Google Calendar (it works from Desktop only).\\nRegister before the course starts using this link.\\nJoin the course Telegram channel with announcements.\\nDon’t forget to register in DataTalks.Club's Slack and join the channel.\",\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - When will the course start?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'You can start by installing and setting up all the dependencies and requirements:\\nGoogle cloud account\\nGoogle Cloud SDK\\nPython 3 (installed with Anaconda)\\nTerraform\\nGit\\nLook over the prerequisites and syllabus to see if you are comfortable with these subjects.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - What can I do before the course starts?',\n",
       "  'course': 'data-engineering-zoomcamp'},\n",
       " {'text': 'Yes, the slack channel remains open and you can ask questions there. But always sDocker containers exit code w search the channel first and second, check the FAQ (this document), most likely all your questions are already answered here.\\nYou can also tag the bot @ZoomcampQABot to help you conduct the search, but don’t rely on its answers 100%, it is pretty good though.',\n",
       "  'section': 'General course-related questions',\n",
       "  'question': 'Course - Can I get support if I take the course in the self-paced mode?',\n",
       "  'course': 'data-engineering-zoomcamp'}]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knowledge_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5138d76e-5748-46b1-95aa-b1fbe46698b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "86073a08-16fb-4a64-bdb7-a81a151e3335",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It depends on the policy of the institution offering the course. Some institutions may allow late enrollment with permission from the instructor or department, while others may have strict deadlines for enrollment. It's best to contact the institution or the course instructor directly to inquire about late enrollment options.\n"
     ]
    }
   ],
   "source": [
    "from openai import OpenAI\n",
    "\n",
    "client = OpenAI(api_key=os.environ.get(\"OPENAI_API_KEY\"))\n",
    "\n",
    "response = client.chat.completions.create(\n",
    "    model=\"gpt-3.5-turbo\",    \n",
    "    messages=[{\"role\": \"user\", \"content\": question}]\n",
    ")\n",
    "print(response.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a81de329-1632-4c38-946d-01eb70545a89",
   "metadata": {},
   "outputs": [],
   "source": [
    "context=''\n",
    "for doc in knowledge_results:\n",
    "    context = context + f\"section: {doc['section']}\\nquestioin:{doc['question']}\\nanswer:{doc['text']}\\n\"\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "31ae5a07-cde1-4cc6-b67b-de06cc0b4ab7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"section: General course-related questions\\nquestioin:Course - Can I still join the course after the start date?\\nanswer:Yes, even if you don't register, you're still eligible to submit the homeworks.\\nBe aware, however, that there will be deadlines for turning in the final projects. So don't leave everything for the last minute.\\nsection: General course-related questions\\nquestioin:Course - Can I follow the course after it finishes?\\nanswer:Yes, we will keep all the materials after the course finishes, so you can follow the course at your own pace after it finishes.\\nYou can also continue looking at the homeworks and continue preparing for the next cohort. I guess you can also start working on your final capstone project.\\nsection: General course-related questions\\nquestioin:Course - When will the course start?\\nanswer:The purpose of this document is to capture frequently asked technical questions\\nThe exact day and hour of the course will be 15th Jan 2024 at 17h00. The course will start with the first  “Office Hours'' live.1\\nSubscribe to course public Google Calendar (it works from Desktop only).\\nRegister before the course starts using this link.\\nJoin the course Telegram channel with announcements.\\nDon’t forget to register in DataTalks.Club's Slack and join the channel.\\nsection: General course-related questions\\nquestioin:Course - What can I do before the course starts?\\nanswer:You can start by installing and setting up all the dependencies and requirements:\\nGoogle cloud account\\nGoogle Cloud SDK\\nPython 3 (installed with Anaconda)\\nTerraform\\nGit\\nLook over the prerequisites and syllabus to see if you are comfortable with these subjects.\\nsection: General course-related questions\\nquestioin:Course - Can I get support if I take the course in the self-paced mode?\\nanswer:Yes, the slack channel remains open and you can ask questions there. But always sDocker containers exit code w search the channel first and second, check the FAQ (this document), most likely all your questions are already answered here.\\nYou can also tag the bot @ZoomcampQABot to help you conduct the search, but don’t rely on its answers 100%, it is pretty good though.\\n\""
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "8900ab7d-ceb8-462b-b717-53fdd2480aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "prompt = f\"\"\"\n",
    "You're a course teaching assistant. Answer the user QUESTION based on CONTEXT - the documents retrieved from our FAQ database. \n",
    "Only use the facts from the CONTEXT. If the CONTEXT doesn't contan the answer, return \"NONE\"\n",
    "\n",
    "QUESTION: {question}\n",
    "\n",
    "CONTEXT:\n",
    "\n",
    "{context}\n",
    "\"\"\".strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "269ba70a-0c91-4cc2-bb89-bdde0ec73e7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def search(query):\n",
    "    boost = {'question':3.0, 'section':.5}\n",
    "    knowledge_results = index.search(query=query, filter_dict={'course':'data-engineering-zoomcamp'},\n",
    "                       boost_dict=boost, num_results=5)\n",
    "    return knowledge_results\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1e3ab64f-208f-4469-803d-a9d67b303f5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_prompt(knowledge_results, query):\n",
    "    context=''\n",
    "    for doc in knowledge_results:\n",
    "        context = context + f\"section: {doc['section']}\\nquestioin:{doc['question']}\\nanswer:{doc['text']}\\n\"\n",
    "    prompt = f\"\"\"\n",
    "    You're a course teaching assistant. Answer the user QUESTION based on CONTEXT - the documents retrieved from our FAQ database. \n",
    "    Only use the facts from the CONTEXT. If the CONTEXT doesn't contan the answer, return \"NONE\"\n",
    "                \n",
    "    QUESTION: {question}\n",
    "                \n",
    "    CONTEXT:\n",
    "                \n",
    "    {context}\n",
    "    \"\"\".strip()\n",
    "    prompt = prompt.format(question=query, context=context)\n",
    "    return prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "80ed8732-51b4-491e-bd42-50e962ccf75b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'You\\'re a course teaching assistant. Answer the user QUESTION based on CONTEXT - the documents retrieved from our FAQ database. \\n    Only use the facts from the CONTEXT. If the CONTEXT doesn\\'t contan the answer, return \"NONE\"\\n                \\n    QUESTION: the course has already started, can I still enroll\\n                \\n    CONTEXT:\\n                \\n    section: Module 6: streaming with kafka\\nquestioin:Java Kafka: How to run producer/consumer/kstreams/etc in terminal\\nanswer:In the project directory, run:\\njava -cp build/libs/<jar_name>-1.0-SNAPSHOT.jar:out src/main/java/org/example/JsonProducer.java\\nsection: Module 6: streaming with kafka\\nquestioin:Module “kafka” not found when trying to run producer.py\\nanswer:Solution from Alexey: create a virtual environment and run requirements.txt and the python files in that environment.\\nTo create a virtual env and install packages (run only once)\\npython -m venv env\\nsource env/bin/activate\\npip install -r ../requirements.txt\\nTo activate it (you\\'ll need to run it every time you need the virtual env):\\nsource env/bin/activate\\nTo deactivate it:\\ndeactivate\\nThis works on MacOS, Linux and Windows - but for Windows the path is slightly different (it\\'s env/Scripts/activate)\\nAlso the virtual environment should be created only to run the python file. Docker images should first all be up and running.\\nsection: Workshop 1 - dlthub\\nquestioin:How do I install the necessary dependencies to run the code?\\nanswer:Answer: To run the provided code, ensure that the \\'dlt[duckdb]\\' package is installed. You can do this by executing the provided installation command: !pip install dlt[duckdb]. If you’re doing it locally, be sure to also have duckdb pip installed (even before the duckdb package is loaded).\\nsection: Module 6: streaming with kafka\\nquestioin:Python Kafka: ./build.sh: Permission denied Error\\nanswer:Run this command in terminal in the same directory (/docker/spark):\\nchmod +x build.sh\\nsection: Project\\nquestioin:How to fix the error \"ModuleNotFoundError: No module named \\'kafka.vendor.six.moves\\'\"?\\nanswer:According to https://github.com/dpkp/kafka-python/\\n“DUE TO ISSUES WITH RELEASES, IT IS SUGGESTED TO USE https://github.com/wbarnha/kafka-python-ng FOR THE TIME BEING”\\nUse pip install kafka-python-ng instead'"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prompt = create_prompt(knowledge_results, question)\n",
    "prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "d2ba0735-ce13-4748-b928-aa82cd6dc1c7",
   "metadata": {},
   "outputs": [],
   "source": [
    "def llm(prompt):\n",
    "    response = client.chat.completions.create(\n",
    "        model=\"gpt-3.5-turbo\",    \n",
    "        messages=[{\"role\": \"user\", \"content\": prompt}]\n",
    "    )\n",
    "    return (response.choices[0].message.content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "5a42113a-c009-4b4a-9575-ea4914221a02",
   "metadata": {},
   "outputs": [],
   "source": [
    "def rag(query):\n",
    "    knowledge_results = search(query)\n",
    "    prompt = create_prompt(knowledge_results, query)\n",
    "    llm(prompt)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "f09c0113-38b7-4321-99a8-2d59f9ea4c97",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "query = 'How to enroll in a course?'\n",
    "print(rag(query))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a8108bcf-30ae-4ee6-a232-7a6b9c24e5a0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "  \"name\" : \"2e4be4601850\",\n",
      "  \"cluster_name\" : \"docker-cluster\",\n",
      "  \"cluster_uuid\" : \"voyOliSjSOK5qJIIE_fAzg\",\n",
      "  \"version\" : {\n",
      "    \"number\" : \"8.4.3\",\n",
      "    \"build_flavor\" : \"default\",\n",
      "    \"build_type\" : \"docker\",\n",
      "    \"build_hash\" : \"42f05b9372a9a4a470db3b52817899b99a76ee73\",\n",
      "    \"build_date\" : \"2022-10-04T07:17:24.662462378Z\",\n",
      "    \"build_snapshot\" : false,\n",
      "    \"lucene_version\" : \"9.3.0\",\n",
      "    \"minimum_wire_compatibility_version\" : \"7.17.0\",\n",
      "    \"minimum_index_compatibility_version\" : \"7.0.0\"\n",
      "  },\n",
      "  \"tagline\" : \"You Know, for Search\"\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "!curl localhost:9200"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5518415d-2f3f-4b9b-909a-074c8fa894a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q1: build_hash\" : \"42f05b9372a9a4a470db3b52817899b99a76ee73"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "09143f14-9a43-45b5-a6e4-9b87fc16cfe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from elasticsearch import Elasticsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "98b84edf-d5d4-42d1-9c67-793e9f17482c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'name': '2e4be4601850', 'cluster_name': 'docker-cluster', 'cluster_uuid': 'voyOliSjSOK5qJIIE_fAzg', 'version': {'number': '8.4.3', 'build_flavor': 'default', 'build_type': 'docker', 'build_hash': '42f05b9372a9a4a470db3b52817899b99a76ee73', 'build_date': '2022-10-04T07:17:24.662462378Z', 'build_snapshot': False, 'lucene_version': '9.3.0', 'minimum_wire_compatibility_version': '7.17.0', 'minimum_index_compatibility_version': '7.0.0'}, 'tagline': 'You Know, for Search'})"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "es = Elasticsearch(\"http://localhost:9200\")\n",
    "es.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "f4088466-b477-4e0a-80b3-4b56eabe63b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'acknowledged': True, 'shards_acknowledged': True, 'index': 'course-questions'})"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "#create index\n",
    "index_settings = {\n",
    "    \"settings\": {\n",
    "        \"number_of_shards\": 1,\n",
    "        \"number_of_replicas\": 0\n",
    "    },\n",
    "    \"mappings\": {\n",
    "        \"properties\": {\n",
    "            \"text\": {\"type\": \"text\"},\n",
    "            \"section\": {\"type\": \"text\"},\n",
    "            \"question\": {\"type\": \"text\"},\n",
    "            \"course\": {\"type\": \"keyword\"} \n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "index_name = \"course-questions\"\n",
    "response = es.indices.create(index=index_name, body=index_settings)\n",
    "\n",
    "response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f8c11196-4b8a-4553-bdd1-f82cd2b64496",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/python/3.10.13/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from tqdm.auto import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83e11a0d-6e6d-4a26-91bf-8efe7b275618",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ddc7dba9-9bbb-4248-aae3-af3c6c7cc8ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bdc222fd-a8fd-4d55-9c40-cc720be722a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "docs_url = 'https://github.com/DataTalksClub/llm-zoomcamp/blob/main/01-intro/documents.json?raw=1'\n",
    "docs_response = requests.get(docs_url)\n",
    "documents_raw = docs_response.json()\n",
    "\n",
    "documents = []\n",
    "\n",
    "for course in documents_raw:\n",
    "    course_name = course['course']\n",
    "\n",
    "    for doc in course['documents']:\n",
    "        doc['course'] = course_name\n",
    "        documents.append(doc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e4bc5b8d-fafa-4b2a-99fe-f8a4eb7ad921",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████████████████████████████████| 948/948 [00:20<00:00, 46.08it/s]\n"
     ]
    }
   ],
   "source": [
    "#index\n",
    "for doc in tqdm(documents):\n",
    "    es.index(index=index_name, document=doc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4337f6f5-9245-4914-9a31-251d5e9c159d",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_question = \"How do I execute a command in a running docker container?\"\n",
    "#question^3 questio is three times more important\n",
    "search_query = {\n",
    "    \"size\": 10,\n",
    "    \"query\": {\n",
    "        \"bool\": {\n",
    "            \"must\": {\n",
    "                \"multi_match\": {\n",
    "                    \"query\": user_question,\n",
    "                    \"fields\": [\"question^4\", \"text\", \"section\"],\n",
    "                    \"type\": \"best_fields\"\n",
    "                }\n",
    "            },\n",
    "#            \"filter\": {\n",
    "#                \"term\": {\n",
    "#                    \"course\": \"machine-learning-zoomcamp\"\n",
    "#                }\n",
    "#            }\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf4062c0-9f0b-4a16-9de6-b7c4c0df57a2",
   "metadata": {},
   "source": [
    "Q3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6bbf067c-b5be-4b72-9946-d655723579fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I debug a docker container?\n",
      "Answer: Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\n",
      "docker run -it --entrypoint bash <image>\n",
      "If the container is already running, execute a command in the specific container:\n",
      "docker ps (find the container-id)\n",
      "docker exec -it <container-id> bash\n",
      "(Marcos MJD)\n",
      "\n",
      "\n",
      "Section: Module 1: Docker and Terraform\n",
      "Question: PGCLI - running in a Docker container\n",
      "Answer: In case running pgcli  locally causes issues or you do not want to install it locally you can use it running in a Docker container instead.\n",
      "Below the usage with values used in the videos of the course for:\n",
      "network name (docker network)\n",
      "postgres related variables for pgcli\n",
      "Hostname\n",
      "Username\n",
      "Port\n",
      "Database name\n",
      "$ docker run -it --rm --network pg-network ai2ys/dockerized-pgcli:4.0.1\n",
      "175dd47cda07:/# pgcli -h pg-database -U root -p 5432 -d ny_taxi\n",
      "Password for root:\n",
      "Server: PostgreSQL 16.1 (Debian 16.1-1.pgdg120+1)\n",
      "Version: 4.0.1\n",
      "Home: http://pgcli.com\n",
      "root@pg-database:ny_taxi> \\dt\n",
      "+--------+------------------+-------+-------+\n",
      "| Schema | Name             | Type  | Owner |\n",
      "|--------+------------------+-------+-------|\n",
      "| public | yellow_taxi_data | table | root  |\n",
      "+--------+------------------+-------+-------+\n",
      "SELECT 1\n",
      "Time: 0.009s\n",
      "root@pg-database:ny_taxi>\n",
      "\n",
      "\n",
      "Section: Module 4: Deployment\n",
      "Question: Running multiple services in a Docker container\n",
      "Answer: If you are trying to run Flask gunicorn & MLFlow server from the same container, defining both in Dockerfile with CMD will only run MLFlow & not Flask.\n",
      "Solution: Create separate shell script with server run commands, for eg:\n",
      "> \tscript1.sh\n",
      "#!/bin/bash\n",
      "gunicorn --bind=0.0.0.0:9696 predict:app\n",
      "Another script with e.g. MLFlow server:\n",
      ">\tscript2.sh\n",
      "#!/bin/bash\n",
      "mlflow server -h 0.0.0.0 -p 5000 --backend-store-uri=sqlite:///mlflow.db --default-artifact-root=g3://zc-bucket/mlruns/\n",
      "Create a wrapper script to run above 2 scripts:\n",
      ">\twrapper_script.sh\n",
      "#!/bin/bash\n",
      "# Start the first process\n",
      "./script1.sh &\n",
      "# Start the second process\n",
      "./script2.sh &\n",
      "# Wait for any process to exit\n",
      "wait -n\n",
      "# Exit with status of process that exited first\n",
      "exit $?\n",
      "Give executable permissions to all scripts:\n",
      "chmod +x *.sh\n",
      "Now we can define last line of Dockerfile as:\n",
      "> \tDockerfile\n",
      "CMD ./wrapper_script.sh\n",
      "Dont forget to expose all ports defined by services!\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I copy files from my local machine to docker container?\n",
      "Answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "To copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\n",
      "docker cp /path/to/local/file_or_directory container_id:/path/in/container\n",
      "Hrithik Kumar Advani\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I copy files from a different folder into docker container’s working directory?\n",
      "Answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "In the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\n",
      "COPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\t\t\t\t\t\t\t\t\t\t\tGopakumar Gopinathan\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: The input device is not a TTY when running docker in interactive mode (Running Docker on Windows in GitBash)\n",
      "Answer: $ docker exec -it 1e5a1b663052 bash\n",
      "the input device is not a TTY.  If you are using mintty, try prefixing the command with 'winpty'\n",
      "Fix:\n",
      "winpty docker exec -it 1e5a1b663052 bash\n",
      "A TTY is a terminal interface that supports escape sequences, moving the cursor around, etc.\n",
      "Winpty is a Windows software package providing an interface similar to a Unix pty-master for communicating with Windows console programs.\n",
      "More info on terminal, shell, console applications hi and so on:\n",
      "https://conemu.github.io/en/TerminalVsShell.html\n",
      "(Marcos MJD)\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How to fix error after running the Docker run command\n",
      "Answer: Solution\n",
      "This error was because there was another instance of gunicorn running. So I thought of removing this along with the zoomcamp_test image. However, it didn’t let me remove the orphan container. So I did the following\n",
      "Running the following commands\n",
      "docker ps -a <to list all docker containers>\n",
      "docker images <to list images>\n",
      "docker stop <container ID>\n",
      "docker rm <container ID>\n",
      "docker rmi image\n",
      "I rebuilt the Docker image, and ran it once again; this time it worked correctly and I was able to serve the test script to the endpoint.\n",
      "\n",
      "\n",
      "Section: Module 6: streaming with kafka\n",
      "Question: How do I check compatibility of local and container Spark versions?\n",
      "Answer: You can check the version of your local spark using spark-submit --version. In the build.sh file of the Python folder, make sure that SPARK_VERSION matches your local version. Similarly, make sure the pyspark you pip installed also matches this version.\n",
      "\n",
      "\n",
      "Section: 4. Evaluation Metrics for Classification\n",
      "Question: How can I annotate a graph?\n",
      "Answer: Matplotlib has a cool method to annotate where you could provide an X,Y point and annotate with an arrow and text. For example this will show an arrow pointing to the x,y point optimal threshold.\n",
      "plt.annotate(f'Optimal Threshold: {optimal_threshold:.2f}\\nOptimal F1 Score: {optimal_f1_score:.2f}',\n",
      "xy=(optimal_threshold, optimal_f1_score),\n",
      "xytext=(0.3, 0.5),\n",
      "textcoords='axes fraction',\n",
      "arrowprops=dict(facecolor='black', shrink=0.05))\n",
      "Quinn Avila\n",
      "\n",
      "\n",
      "Section: 9. Serverless Deep Learning\n",
      "Question: How do Lambda container images work?\n",
      "Answer: I wanted to understand how lambda container images work in depth and how lambda functions are initialized, for this reason, I found the following documentation\n",
      "https://docs.aws.amazon.com/lambda/latest/dg/images-create.html\n",
      "https://docs.aws.amazon.com/lambda/latest/dg/runtimes-api.html\n",
      "Added by Alejandro aponte\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "response = es.search(index=index_name, body=search_query)\n",
    "max_score = 0\n",
    "for hit in response['hits']['hits']:\n",
    "    doc = hit['_source']\n",
    "    if hit['_score'] > max_score:\n",
    "        max_score = hit['_score']\n",
    "    print(f\"Section: {doc['section']}\\nQuestion: {doc['question']}\\nAnswer: {doc['text']}\\n\\n\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a3e8e7eb-3569-45a9-8ced-4e8babb13ee5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q3: max score 84.050095\n"
     ]
    }
   ],
   "source": [
    "print('Q3: max score', max_score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58886ec9-370d-450c-ad34-a674fa483860",
   "metadata": {},
   "outputs": [],
   "source": [
    "Q4\n",
    "Now let's only limit the questions to machine-learning-zoomcamp.\n",
    "\n",
    "Return 3 results. What's the 3rd question returned by the search engine?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "56d70623-3806-46ee-8932-75e899e360f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "user_question = \"How do I execute a command in a running docker container?\"\n",
    "#question^3 questio is three times more important\n",
    "search_query = {\n",
    "    \"size\": 3,\n",
    "    \"query\": {\n",
    "        \"bool\": {\n",
    "            \"must\": {\n",
    "                \"multi_match\": {\n",
    "                    \"query\": user_question,\n",
    "                    \"fields\": [\"question^4\", \"text\", \"section\"],\n",
    "                    \"type\": \"best_fields\"\n",
    "                }\n",
    "            },\n",
    "            \"filter\": {\n",
    "                \"term\": {\n",
    "                    \"course\": \"machine-learning-zoomcamp\"\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "14de2762-ce5e-4078-875d-0b94b5a12799",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I debug a docker container?\n",
      "Answer: Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\n",
      "docker run -it --entrypoint bash <image>\n",
      "If the container is already running, execute a command in the specific container:\n",
      "docker ps (find the container-id)\n",
      "docker exec -it <container-id> bash\n",
      "(Marcos MJD)\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I copy files from my local machine to docker container?\n",
      "Answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "To copy a file or directory from your local machine into a running Docker container, you can use the `docker cp command`. The basic syntax is as follows:\n",
      "docker cp /path/to/local/file_or_directory container_id:/path/in/container\n",
      "Hrithik Kumar Advani\n",
      "\n",
      "\n",
      "Section: 5. Deploying Machine Learning Models\n",
      "Question: How do I copy files from a different folder into docker container’s working directory?\n",
      "Answer: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\n",
      "In the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\n",
      "COPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\t\t\t\t\t\t\t\t\t\t\tGopakumar Gopinathan\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "response = es.search(index=index_name, body=search_query)\n",
    "max_score = 0\n",
    "for hit in response['hits']['hits']:\n",
    "    doc = hit['_source']\n",
    "    if hit['_score'] > max_score:\n",
    "        max_score = hit['_score']\n",
    "    print(f\"Section: {doc['section']}\\nQuestion: {doc['question']}\\nAnswer: {doc['text']}\\n\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "c4369b14-84af-45ab-9e33-495ae7c11d6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#response['hits']['hits']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "8dcbf70a-7643-4c7d-b252-0a5fbadaefa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "75.54128"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " response['hits']['hits'][0]['_score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "78737b6f-a2c6-442a-9078-649180cbc2bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_prompt_elastic(es_results, query):\n",
    "    context=''\n",
    "    for doc in es_results['hits']['hits']:\n",
    "        doc = hit['_source']\n",
    "        context = context + f'''\n",
    "        Q: {doc['question']}\n",
    "        A: {doc['text']}\\n\\n'''\n",
    "    context = context.strip()\n",
    "    prompt_template = \"\"\"\n",
    "You're a course teaching assistant. Answer the QUESTION based on the CONTEXT from the FAQ database.\n",
    "Use only the facts from the CONTEXT when answering the QUESTION.\n",
    "\n",
    "QUESTION: {question}\n",
    "\n",
    "CONTEXT:\n",
    "{context}\n",
    "\"\"\".strip()\n",
    "    prompt = prompt_template.format(question=query, context=context)\n",
    "    return prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "80ef51aa-f686-4ab7-a2f8-d5d6b6dea8b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 5. Prompt length 1553\n"
     ]
    }
   ],
   "source": [
    "question = \"How do I execute a command in a running docker container?\" \n",
    "prompt = create_prompt_elastic(response, question)\n",
    "print('Question 5. Prompt length', len(create_prompt_elastic(response, question)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "4d6be487-f138-4b15-b4db-95108ab0cdf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Q6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "791da396-6fd2-4b37-abd9-b704168b69b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting tiktoken\n",
      "  Downloading tiktoken-0.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.6 kB)\n",
      "Collecting regex>=2022.1.18 (from tiktoken)\n",
      "  Downloading regex-2024.5.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (40 kB)\n",
      "\u001b[2K     \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m40.9/40.9 kB\u001b[0m \u001b[31m1.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
      "\u001b[?25hRequirement already satisfied: requests>=2.26.0 in /home/codespace/.local/lib/python3.10/site-packages (from tiktoken) (2.32.3)\n",
      "Requirement already satisfied: charset-normalizer<4,>=2 in /home/codespace/.local/lib/python3.10/site-packages (from requests>=2.26.0->tiktoken) (3.3.2)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /home/codespace/.local/lib/python3.10/site-packages (from requests>=2.26.0->tiktoken) (3.7)\n",
      "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/python/3.10.13/lib/python3.10/site-packages (from requests>=2.26.0->tiktoken) (2.0.7)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /home/codespace/.local/lib/python3.10/site-packages (from requests>=2.26.0->tiktoken) (2024.2.2)\n",
      "Downloading tiktoken-0.7.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n",
      "\u001b[2K   \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m18.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hDownloading regex-2024.5.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (775 kB)\n",
      "\u001b[2K   \u001b[38;2;114;156;31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m775.1/775.1 kB\u001b[0m \u001b[31m17.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0mm eta \u001b[36m0:00:01\u001b[0m\n",
      "\u001b[?25hInstalling collected packages: regex, tiktoken\n",
      "Successfully installed regex-2024.5.15 tiktoken-0.7.0\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m24.0\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.1.1\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install tiktoken"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "7a327a0d-2b3b-4321-9867-1e12d1032e5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import tiktoken\n",
    "encoding = tiktoken.encoding_for_model(\"gpt-4o\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "fbbc5605-d6c1-46f8-a623-659cd044041e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Question 6. Number of tokens  338\n"
     ]
    }
   ],
   "source": [
    "#Q6\n",
    "print('Question 6. Number of tokens ', len(encoding.encode(prompt)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edde0c6e-5340-45e1-b6f8-cc831978b3b2",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}