01-intro/homework_sd.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "20f458ab-9d09-480b-b737-ce37f4b2badb",
   "metadata": {},
   "source": [
    "# Q1. Running Elastic\n",
    "Run Elastic Search 8.4.3, and get the cluster information. If you run it on localhost, this is how you do it:\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0a54216-00b4-405b-96af-812f4702deea",
   "metadata": {},
   "source": [
    "curl localhost:9200"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0317db94-c5dd-47b2-8a72-42ee62605cec",
   "metadata": {},
   "source": [
    "What's the version.build_hash value?\n",
    "\n",
    "# 42f05b9372a9a4a470db3b52817899b99a76ee73\n",
    "\n",
    "{\n",
    "  \"name\" : \"fc47f19a75f9\",\n",
    "  \"cluster_name\" : \"docker-cluster\",\n",
    "  \"cluster_uuid\" : \"Nf8oH9YgRti6QUmEkqp3Bw\",\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",
    "  },"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8038a66-f0c2-4169-aabf-afe623ec7d13",
   "metadata": {},
   "source": [
    "# Getting the data\n",
    "Now let's get the FAQ data. You can run this snippet:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "448d2d15-f69b-479f-9f97-e28b99b6f968",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests \n",
    "\n",
    "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": null,
   "id": "513c4739-653e-4868-b880-3bc8e176b414",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "48352614-7d5d-4e32-bbd6-9bb70ad26e97",
   "metadata": {},
   "outputs": [],
   "source": [
    "from elasticsearch import Elasticsearch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e68f3316-4c68-40e5-a220-1b331de50cee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'name': '4f71a0e27f36', 'cluster_name': 'docker-cluster', 'cluster_uuid': '3A0SdirXQOeXH20E0s1Hhg', '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": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "es_client = Elasticsearch('http://localhost:9200')\n",
    "\n",
    "es_client.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "67a98474-7738-4053-9181-952d87c5cf20",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ObjectApiResponse({'acknowledged': True, 'shards_acknowledged': True, 'index': 'course-questions'})"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creating an index in Elastic similar\n",
    "\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",
    "\n",
    "es_client.indices.create(index = index_name, body=index_settings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68bd4c3d-9303-4213-821d-bba2b768139b",
   "metadata": {},
   "source": [
    "# Q2. Indexing the data\n",
    "\n",
    "Which function do you use for adding your data to elastic?\n",
    "\n",
    "insert \n",
    "## index ---- correct answer\n",
    "put\n",
    "add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "56fe7027-b092-4ca3-91e2-fcbe0fe0a9b2",
   "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": 6,
   "id": "4b0fc477-4c6b-4d0a-85f1-4d8a3bb534c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████| 948/948 [00:24<00:00, 39.12it/s]\n"
     ]
    }
   ],
   "source": [
    "for doc in tqdm(documents):\n",
    "    es_client.index(index=index_name, \n",
    "                    document=doc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4965f527-faef-4e8d-b670-a72fc20382dc",
   "metadata": {},
   "source": [
    "# Q3. Searching\n",
    "\n",
    "\n",
    "Now let's search in our index.\n",
    "\n",
    "We will execute a query \"How do I execute a command in a running docker container?\".\n",
    "\n",
    "Use only question and text fields and give question a boost of 4, and use \"type\": \"best_fields\".\n",
    "\n",
    "What's the score for the top ranking result?\n",
    "\n",
    ">*94.05\n",
    ">*84.05\n",
    ">* # 74.05 correct answer\n",
    ">*64.05\n",
    "\n",
    "Look at the _score field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6f56291e-465a-4906-a0d9-d726d94772c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "def elastic_search(query):\n",
    "    \n",
    "    search_query = {\n",
    "        \"size\": 5,\n",
    "        \"query\": {\n",
    "            \"bool\": {\n",
    "                \"must\": {\n",
    "                    \"multi_match\": {\n",
    "                        \"query\": query,\n",
    "                        \"fields\": [\"question^4\", \"text\", \"section\"],\n",
    "                        \"type\": \"best_fields\"\n",
    "                    }\n",
    "                },\n",
    "                \"filter\": {\n",
    "                    \"term\": {\n",
    "                        \"course\": \"data-engineering-zoomcamp\"\n",
    "                    }\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "\n",
    "    response = es_client.search(index = index_name, body=search_query)\n",
    "    \n",
    "    result_docs = []\n",
    "    \n",
    "    for hit in response ['hits']['hits']:\n",
    "        result_docs.append(hit['_score'])\n",
    "    \n",
    "    \n",
    "    return result_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c32b41b1-ab2a-45d5-8eaa-b3d2a321b7d0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "02c11f2f-3807-4ae7-909c-eb1e392b9f06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[75.54128, 43.922554, 38.684105, 38.33403, 35.94081]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = \"How do I execute a command in a running docker container?\"\n",
    "elastic_search(query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "533b8878-1655-4426-9fce-be41f4b2288b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[75.54128, 43.922554, 38.684105, 38.33403, 35.94081]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "search_query = {\n",
    "    \"size\": 5,\n",
    "    \"query\": {\n",
    "        \"bool\": {\n",
    "            \"must\": {\n",
    "                \"multi_match\": {\n",
    "                    \"query\": query,\n",
    "                    \"fields\": [\"question^4\", \"text\", \"section\"],\n",
    "                    \"type\": \"best_fields\"\n",
    "                }\n",
    "            },\n",
    "            \"filter\": {\n",
    "                \"term\": {\n",
    "                    \"course\": \"data-engineering-zoomcamp\"\n",
    "                }\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "}\n",
    "\n",
    "response = es_client.search(index = index_name, body=search_query)\n",
    "\n",
    "result_docs = []\n",
    "\n",
    "for hit in response ['hits']['hits']:\n",
    "    result_docs.append(hit['_score'])\n",
    "\n",
    "\n",
    "result_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e13ef324-4214-4910-878e-f232a3d43be1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'_index': 'course-questions',\n",
       "  '_id': 'FUSzO5ABhbz_olOMgQZf',\n",
       "  '_score': 75.54128,\n",
       "  '_source': {'text': '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.\\nBelow the usage with values used in the videos of the course for:\\nnetwork name (docker network)\\npostgres related variables for pgcli\\nHostname\\nUsername\\nPort\\nDatabase name\\n$ docker run -it --rm --network pg-network ai2ys/dockerized-pgcli:4.0.1\\n175dd47cda07:/# pgcli -h pg-database -U root -p 5432 -d ny_taxi\\nPassword for root:\\nServer: PostgreSQL 16.1 (Debian 16.1-1.pgdg120+1)\\nVersion: 4.0.1\\nHome: http://pgcli.com\\nroot@pg-database:ny_taxi> \\\\dt\\n+--------+------------------+-------+-------+\\n| Schema | Name             | Type  | Owner |\\n|--------+------------------+-------+-------|\\n| public | yellow_taxi_data | table | root  |\\n+--------+------------------+-------+-------+\\nSELECT 1\\nTime: 0.009s\\nroot@pg-database:ny_taxi>',\n",
       "   'section': 'Module 1: Docker and Terraform',\n",
       "   'question': 'PGCLI - running in a Docker container',\n",
       "   'course': 'data-engineering-zoomcamp'}},\n",
       " {'_index': 'course-questions',\n",
       "  '_id': 'NESzO5ABhbz_olOMnQfK',\n",
       "  '_score': 43.922554,\n",
       "  '_source': {'text': '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",
       "   'section': 'Module 6: streaming with kafka',\n",
       "   'question': 'How do I check compatibility of local and container Spark versions?',\n",
       "   'course': 'data-engineering-zoomcamp'}},\n",
       " {'_index': 'course-questions',\n",
       "  '_id': 'sESzO5ABhbz_olOMdgXa',\n",
       "  '_score': 38.684105,\n",
       "  '_source': {'text': \"There are 3 Zoom Camps in a year, as of 2024. However, they are for separate courses:\\nData-Engineering (Jan - Apr)\\nMLOps (May - Aug)\\nMachine Learning (Sep - Jan)\\nThere's only one Data-Engineering Zoomcamp “live” cohort per year, for the certification. Same as for the other Zoomcamps.\\nThey follow pretty much the same schedule for each cohort per zoomcamp. For Data-Engineering it is (generally) from Jan-Apr of the year. If you’re not interested in the Certificate, you can take any zoom camps at any time, at your own pace, out of sync with any “live” cohort.\",\n",
       "   'section': 'General course-related questions',\n",
       "   'question': 'Course - how many Zoomcamps in a year?',\n",
       "   'course': 'data-engineering-zoomcamp'}},\n",
       " {'_index': 'course-questions',\n",
       "  '_id': '5ESzO5ABhbz_olOMfAVY',\n",
       "  '_score': 38.33403,\n",
       "  '_source': {'text': \"It is recommended by the Docker do\\n[Windows 10 / 11 Home Edition] If you're running a Home Edition, you can still make it work with WSL2 (Windows Subsystem for Linux) by following the tutorial here\\nIf even after making sure your WSL2 (or Hyper-V) is set up accordingly, Docker remains stuck, you can try the option to Reset to Factory Defaults or do a fresh install.\",\n",
       "   'section': 'Module 1: Docker and Terraform',\n",
       "   'question': 'Should I run docker commands from the windows file system or a file system of a Linux distribution in WSL?',\n",
       "   'course': 'data-engineering-zoomcamp'}},\n",
       " {'_index': 'course-questions',\n",
       "  '_id': 'tkSzO5ABhbz_olOMdwWB',\n",
       "  '_score': 35.94081,\n",
       "  '_source': {'text': \"No, you can only get a certificate if you finish the course with a “live” cohort. We don't award certificates for the self-paced mode. The reason is you need to peer-review capstone(s) after submitting a project. You can only peer-review projects at the time the course is running.\",\n",
       "   'section': 'General course-related questions',\n",
       "   'question': 'Certificate - Can I follow the course in a self-paced mode and get a certificate?',\n",
       "   'course': 'data-engineering-zoomcamp'}}]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "response['hits']['hits']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2140cdfe-d2a9-44c1-a41f-33f7576b8ee7",
   "metadata": {},
   "source": [
    "# Q4. Filtering\n",
    "\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",
    "\n",
    ">* How do I debug a docker container?\n",
    ">* # How do I copy files from a different folder into docker container’s working directory? -- correct answer\n",
    ">* How do Lambda container images work?\n",
    "\n",
    ">* How can I annotate a graph?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bce22d00-783b-4bae-af7d-b860572e84ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'How do I copy files from a different folder into docker container’s working directory?'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "search_query = {\n",
    "    \"size\": 3,\n",
    "    \"query\": {\n",
    "        \"bool\": {\n",
    "            \"must\": {\n",
    "                \"multi_match\": {\n",
    "                    \"query\": query,\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",
    "}\n",
    "\n",
    "response = es_client.search(index = index_name, body=search_query)\n",
    "\n",
    "result_docs = []\n",
    "\n",
    "for hit in response ['hits']['hits']:\n",
    "    result_docs.append(hit['_source'])\n",
    "\n",
    "\n",
    "result_docs[2]['question']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8a27208e-f4e4-417b-8a29-099c874deb8c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'text': 'Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)',\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I debug a docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': \"You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\\nTo 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:\\ndocker cp /path/to/local/file_or_directory container_id:/path/in/container\\nHrithik Kumar Advani\",\n",
       "  'section': '5. Deploying Machine Learning Models',\n",
       "  'question': 'How do I copy files from my local machine to docker container?',\n",
       "  'course': 'machine-learning-zoomcamp'},\n",
       " {'text': 'You can copy files from your local machine into a Docker container using the docker cp command. Here\\'s how to do it:\\nIn the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\\nCOPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tGopakumar Gopinathan',\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",
       "  'course': 'machine-learning-zoomcamp'}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result_docs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3956d442-43fd-4a85-a18c-96bbc850f962",
   "metadata": {},
   "source": [
    "# Q5. Building a prompt\n",
    "\n",
    "Now we're ready to build a prompt to send to an LLM.\n",
    "\n",
    "Take the records returned from Elasticsearch in Q4 and use this template to build the context. Separate context entries by two linebreaks (\\n\\n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2488da97-3e42-4f31-ae65-870f708b934c",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openai import OpenAI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "83f94cf9-95cb-48ff-ad2c-ceb0b5dcfb9a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q: How do I debug a docker container?\n",
      "A: 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",
      "Q: How do I copy files from my local machine to docker container?\n",
      "A: 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",
      "Q: How do I copy files from a different folder into docker container’s working directory?\n",
      "A: 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"
     ]
    }
   ],
   "source": [
    "context_template = \"\"\"\n",
    "Q: {question}\n",
    "A: {text}\n",
    "\"\"\".strip()\n",
    "\n",
    "# Build the context string\n",
    "context_entries = [context_template.format(question=doc[\"question\"], text=doc[\"text\"]) for doc in result_docs]\n",
    "context = \"\\n\\n\".join(context_entries)\n",
    "\n",
    "len(context)\n",
    "print(context)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bb19870-59e1-4df7-b79d-217e0ce2c9c2",
   "metadata": {},
   "source": [
    "## Now use the context you just created along with the \"How do I execute a command in a running docker container?\" question to construct a prompt using the template below:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6567eff4-6a77-4a11-a465-d9c8b440bfaa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "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: How do I execute a command in a running docker container?\n",
      "\n",
      "CONTEXT:Q: How do I debug a docker container?\n",
      "A: 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",
      "Q: How do I copy files from my local machine to docker container?\n",
      "A: 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",
      "Q: How do I copy files from a different folder into docker container’s working directory?\n",
      "A: 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"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1461"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = \"How do I execute a command in a running docker container?\"\n",
    "\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:{context}\n",
    "\"\"\".strip()\n",
    "\n",
    "# Construct the prompt\n",
    "prompt = prompt_template.format(question=query, context=context)\n",
    "\n",
    "print(prompt)\n",
    "len(prompt)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57dae602-48f0-43e4-b7e6-8901e1b5dc72",
   "metadata": {},
   "source": [
    "# What's the length of the resulting prompt? (use the len function)\n",
    "\n",
    ">* 962\n",
    ">* # 1462 correct answer\n",
    ">* 1962\n",
    ">* 2462"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d9af31be-06d0-42f5-b84b-656884190759",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "51e1cf22-b825-445a-bdf8-005107a05916",
   "metadata": {},
   "source": [
    "# Q6. Tokens\n",
    "\n",
    "When we use the OpenAI Platform, we're charged by the number of tokens we send in our prompt and receive in the response.\n",
    "\n",
    "The OpenAI python package uses tiktoken for tokenization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dc36de3b-0345-4947-8c56-5534dac4c39d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: tiktoken in /usr/local/python/3.10.13/lib/python3.10/site-packages (0.7.0)\n",
      "Requirement already satisfied: regex>=2022.1.18 in /usr/local/python/3.10.13/lib/python3.10/site-packages (from tiktoken) (2024.5.15)\n",
      "Requirement 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",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install tiktoken\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "869b20b7-2ec0-49ea-b1c4-d162fba32685",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Let's calculate the number of tokens in our query:\n",
    "import tiktoken\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5972bf15-5b8b-45b6-86bf-cbd7d3329e62",
   "metadata": {},
   "outputs": [],
   "source": [
    "def num_tokens_from_string(string: str, encoding_name: str) -> int:\n",
    "    \"\"\"Returns the number of tokens in a text string.\"\"\"\n",
    "    encoding = tiktoken.encoding_for_model(\"gpt-4o\")\n",
    "    num_tokens = len(encoding.encode(string))\n",
    "    return num_tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "34434c9a-be6c-4943-8bf0-eea6e2321fb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "322"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_tokens_from_string(prompt, \"o200k_base\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a8e3dd8-8c6a-4260-954c-5349b0937117",
   "metadata": {},
   "source": [
    "## Use the encode function. How many tokens does our prompt have?\n",
    "\n",
    ">* 122\n",
    ">* 222\n",
    ">* # 322 correct answer\n",
    ">* 422"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25189444-8a25-40a7-9af6-e513534381e6",
   "metadata": {},
   "source": [
    "Note: to decode back a token into a word, you can use the decode_single_token_bytes function:\n",
    "\n",
    "encoding.decode_single_token_bytes(63842)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5888a873-eb5f-4a0b-a60e-e5e213050d38",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "06c986e7-1d64-48c3-ad1a-0920c4652387",
   "metadata": {},
   "source": [
    "# Bonus: calculating the costs (ungraded)\n",
    "Suppose that on average per request we send 150 tokens and receive back 250 tokens.\n",
    "\n",
    "How much will it cost to run 1000 requests?\n",
    "\n",
    "You can see the prices here\n",
    "\n",
    "On June 17, the prices for gpt4o are:\n",
    "\n",
    "Input: $0.005 / 1K tokens\n",
    "Output: $0.015 / 1K tokens\n",
    "You can redo the calculations with the values you got in Q6 and Q7."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2404c444-15cc-4149-a9f1-4d33eedeb46b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "322"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_tokens_from_string(prompt, \"o200k_base\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "632ac66c-ce57-44c1-9b1e-e88f9bdc668f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Total cost of 1000 requests is USD 4.50'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Suppose that on average per request we send 150 tokens and receive back 250 tokens.\n",
    "\n",
    "#How much will it cost to run 1000 requests?\n",
    "\n",
    "total_tokens_sent =  1000 * 150\n",
    "total_tokens_received =  1000 * 250\n",
    "\n",
    "cost_sent = total_tokens_sent * (0.005/1000)\n",
    "cost_received = total_tokens_received * (0.015/1000)\n",
    "\n",
    "total_cost = cost_sent + cost_received\n",
    "\n",
    "f\"Total cost of 1000 requests is USD {total_cost:.2f}\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a4ece18-465d-421d-a33e-b519df1464b6",
   "metadata": {},
   "source": [
    "# Bonus: generating the answer (ungraded)\n",
    "Let's send the prompt to OpenAI. What's the response?\n",
    "\n",
    "Note: you can replace OpenAI with Ollama. See module 2."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5acd303b-427f-4504-ae29-f38d0e05fed4",
   "metadata": {},
   "source": [
    "## Using Cohere free trial API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e48724dc-a11b-40f3-ba7b-23b15743d066",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cohere"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5129b2dc-2a7d-4011-9ae0-7263e6bfc353",
   "metadata": {},
   "outputs": [],
   "source": [
    "co = cohere.Client()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "37a16fab-27f7-4030-9205-34f8351e4bda",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'title': 'chunk 0',\n",
       "  'snippet': 'Q: How do I debug a docker container?\\nA: Launch the container image in interactive mode and overriding the entrypoint, so that it starts a bash command.\\ndocker run -it --entrypoint bash <image>\\nIf the container is already running, execute a command in the specific container:\\ndocker ps (find the container-id)\\ndocker exec -it <container-id> bash\\n(Marcos MJD)'},\n",
       " {'title': 'chunk 1',\n",
       "  'snippet': \"Q: How do I copy files from my local machine to docker container?\\nA: You can copy files from your local machine into a Docker container using the docker cp command. Here's how to do it:\\nTo 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:\\ndocker cp /path/to/local/file_or_directory container_id:/path/in/container\\nHrithik Kumar Advani\"},\n",
       " {'title': 'chunk 2',\n",
       "  'snippet': 'Q: How do I copy files from a different folder into docker container’s working directory?\\nA: You can copy files from your local machine into a Docker container using the docker cp command. Here\\'s how to do it:\\nIn the Dockerfile, you can provide the folder containing the files that you want to copy over. The basic syntax is as follows:\\nCOPY [\"src/predict.py\", \"models/xgb_model.bin\", \"./\"]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tGopakumar Gopinathan'}]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Preamble\n",
    "preamble = \"You're a course teaching assistant. Answer the QUESTION based on the CONTEXT from the FAQ database.\"\n",
    "\n",
    "# Split the context string into individual question-answer pairs\n",
    "qa_pairs = context.split(\"\\n\\n\")\n",
    "\n",
    "# Create the documents list\n",
    "documents = [{\"title\": f\"chunk {idx}\", \"snippet\": qa_pair.strip()} for idx, qa_pair in enumerate(qa_pairs)]\n",
    "\n",
    "# Example of how the documents list looks like\n",
    "documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "0003a74d-db3d-4710-9e6c-ce78434f0a72",
   "metadata": {},
   "outputs": [],
   "source": [
    "#passing the query to cohere api\n",
    "response = co.chat(\n",
    "    message=query,\n",
    "    documents=documents,\n",
    "    preamble=preamble, \n",
    "    model=\"command-r\",\n",
    ")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2d17040b-95bf-4fc9-a23e-0942aa9b6941",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final answer:\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'To execute a command in a running Docker container, first find the container ID by running the command docker ps. Then, use the following command to execute a command in the specific container:\\ndocker exec -it <container-id> bash'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Final answer:\")\n",
    "response.text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb29a4f9-37e9-4212-8d54-cd4d62dc264a",
   "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
}