Upload 🗣️QuestionMyDoc📄_with_LangChain (Assignment Version) (1).ipynb

🗣️QuestionMyDoc📄_with_LangChain (Assignment Version) (1).ipynb

@@ -0,0 +1,714 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kEKghJQ2pmYH"
+   },
+   "source": [
+    "### The Basics of LangChain\n",
+    "\n",
+    "In this notebook we'll explore exactly what LangChain is doing - and implement a straightforward example that lets us ask questions of a document!\n",
+    "\n",
+    "First things first, let's get our dependencies all set!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "fXsYHTgvnCM2",
+    "outputId": "36fb461a-25aa-4ffe-c684-1ca6f8eb0904"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install openai langchain python-dotenv -q"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "T0sLjfy8p3jf"
+   },
+   "source": [
+    "You'll need to have an OpenAI API key for this next part - see [this](https://www.onmsft.com/how-to/how-to-get-an-openai-api-key/) if you haven't already set one up!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!echo openai_api_key=\"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\" > .env"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "id": "0TTosnCHnGHG"
+   },
+   "outputs": [],
+   "source": [
+    "import os \n",
+    "import openai\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv(\".env\")\n",
+    "\n",
+    "openai.api_key = os.environ.get(\"openai_api_key\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "15M3Jx6SBXcO"
+   },
+   "source": [
+    "#### Helper Functions (run this cell)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "id": "k3SBzWBUpQ21"
+   },
+   "outputs": [],
+   "source": [
+    "from IPython.display import display, Markdown\n",
+    "\n",
+    "def disp_markdown(text: str) -> None:\n",
+    "  display(Markdown(text))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fU4LWrv-BayH"
+   },
+   "source": [
+    "### Our First LangChain ChatModel"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "p-M-VQhQOC1c"
+   },
+   "source": [
+    "\n",
+    "\n",
+    "---\n",
+    "\n",
+    "\n",
+    "<div class=\"warn\">Note: Information on OpenAI's <a href=https://openai.com/pricing>pricing</a> and <a href=https://openai.com/policies/usage-policies>usage policies.</a></div>\n",
+    "\n",
+    "\n",
+    "\n",
+    "---\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "XVkfqk4NOFWS"
+   },
+   "source": [
+    "Now that we're set-up with OpenAI's API - we can begin making our first ChatModel!\n",
+    "\n",
+    "There's a few important things to consider when we're using LangChain's ChatModel that are outlined [here](https://python.langchain.com/docs/modules/model_io/models/chat/)\n",
+    "\n",
+    "Let's begin by initializing the model with OpenAI's `gpt-3.5-turbo` (ChatGPT) model.\n",
+    "\n",
+    "We're not going to be leveraging the [streaming](https://python.langchain.com/docs/modules/model_io/models/chat/how_to/streaming) capabilities in this Notebook - just the basics to get us started!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "id": "tNscLft_nxBb"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.chat_models import ChatOpenAI\n",
+    "from langchain.schema import HumanMessage\n",
+    "\n",
+    "chat_model = ChatOpenAI(model_name=\"gpt-3.5-turbo\", openai_api_key=os.environ.get(\"openai_api_key\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "vzGhlpwUPyU9"
+   },
+   "source": [
+    "If we look at the [Chat completions](https://platform.openai.com/docs/guides/chat) documentation for OpenAI's chat models - we'll see that there are a few specific fields we'll need to concern ourselves with:\n",
+    "\n",
+    "`role`\n",
+    "- This refers to one of three \"roles\" that interact with the model in specific ways.\n",
+    "- The `system` role is an optional role that can be used to guide the model toward a specific task. Examples of `system` messages might be: \n",
+    "  - You are an expert in Python, please answer questions as though we were in a peer coding session.\n",
+    "  - You are the world's leading expert in stamps.\n",
+    "\n",
+    "  These messages help us \"prime\" the model to be more aligned with our desired task!\n",
+    "\n",
+    "- The `user` role represents, well, the user!\n",
+    "- The `assistant` role lets us act in the place of the model's outputs. We can (and will) leverage this for some few-shot prompt engineering!\n",
+    "\n",
+    "Each of these roles has a class in LangChain to make it nice and easy for us to use! \n",
+    "\n",
+    "Let's look at an example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "id": "dM7lciZtoPEp"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.schema import (\n",
+    "    AIMessage, \n",
+    "    HumanMessage,\n",
+    "    SystemMessage\n",
+    ")\n",
+    "\n",
+    "# The SystemMessage is associated with the system role\n",
+    "system_message = SystemMessage(content=\"You are a food critic.\")\n",
+    "\n",
+    "# The HumanMessage is associated with the user role\n",
+    "user_message = HumanMessage(content=\"Do you think Kraft Dinner constitues fine dining?\")\n",
+    "\n",
+    "# The AIMessage is associated with the assistant role\n",
+    "assistant_message = AIMessage(content=\"Egads! No, it most certainly does not!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dSx5HBgjSUvB"
+   },
+   "source": [
+    "Now that we have those messages set-up, let's send them to `gpt-3.5-turbo` with a new user message and see how it does!\n",
+    "\n",
+    "It's easy enough to do this - the ChatOpenAI model accepts a list of inputs!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "LwDLOYOKSTpG",
+    "outputId": "94160cfc-c5b6-4825-8838-32e2476bcb73"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "AIMessage(content=\"Ah, Red Lobster. While it may be a step up from Kraft Dinner, I wouldn't classify it as fine dining either. Red Lobster is more of a casual dining chain that focuses on seafood. It's known for its affordable prices and popular menu items like their Cheddar Bay Biscuits and endless shrimp promotion. While it may be a fun and enjoyable dining experience, it doesn't quite reach the level of sophistication and refinement that is typically associated with fine dining establishments.\", additional_kwargs={}, example=False)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "second_user_message = HumanMessage(content=\"What about Red Lobster, surely that is fine dining!\")\n",
+    "\n",
+    "# create the list of prompts\n",
+    "list_of_prompts = [\n",
+    "    system_message,\n",
+    "    user_message,\n",
+    "    assistant_message,\n",
+    "    second_user_message\n",
+    "]\n",
+    "\n",
+    "# we can just call our chat_model on the list of prompts!\n",
+    "chat_model(list_of_prompts)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "pZMYJDWXTkMq"
+   },
+   "source": [
+    "Great! That's inline with what we expected to see!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "8DUNhabQUB8f"
+   },
+   "source": [
+    "### PromptTemplates\n",
+    "\n",
+    "Next stop, we'll discuss a few templates. This allows us to easily interact with our model by not having to redo work we've already completed!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "id": "74vpojywT0-4"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.prompts.chat import (\n",
+    "    ChatPromptTemplate,\n",
+    "    SystemMessagePromptTemplate,\n",
+    "    HumanMessagePromptTemplate\n",
+    ")\n",
+    "\n",
+    "# we can signify variables we want access to by wrapping them in {}\n",
+    "system_prompt_template = \"You are an expert in {SUBJECT}, and you're currently feeling {MOOD}\"\n",
+    "system_prompt_template = SystemMessagePromptTemplate.from_template(system_prompt_template)\n",
+    "\n",
+    "user_prompt_template = \"{CONTENT}\"\n",
+    "user_prompt_template = HumanMessagePromptTemplate.from_template(user_prompt_template)\n",
+    "\n",
+    "# put them together into a ChatPromptTemplate\n",
+    "chat_prompt = ChatPromptTemplate.from_messages([system_prompt_template, user_prompt_template])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "a-nbEW-kV_na"
+   },
+   "source": [
+    "Now that we have our `chat_prompt` set-up with the templates - let's see how we can easily format them with our content!\n",
+    "\n",
+    "NOTE: `disp_markdown` is just a helper function to display the formatted markdown response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 337
+    },
+    "id": "P4vd-W2FV7Xq",
+    "outputId": "2c4bda02-7ba3-4d72-f6d2-dddeed8c3385"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "Hello! As an expert in cheeses, I can certainly help you with that. When it comes to the finest cheeses, there are a few that stand out:\n",
+       "\n",
+       "1. Parmigiano Reggiano: Known as the \"king of cheeses,\" Parmigiano Reggiano is a hard, aged Italian cheese. It has a rich, nutty flavor with a slightly grainy texture. It's commonly used for grating over pasta or salads.\n",
+       "\n",
+       "2. Gruyère: This Swiss cheese is well-known for its complex and nutty flavor. It has a firm, creamy texture, making it perfect for melting in dishes like quiches or fondue.\n",
+       "\n",
+       "3. Roquefort: A famous blue cheese from France, Roquefort is made from sheep's milk and aged in caves. It has a strong, tangy flavor with a creamy and crumbly texture. This cheese pairs well with fruits and honey.\n",
+       "\n",
+       "4. Brie de Meaux: A classic French cheese, Brie de Meaux is a soft, creamy cheese with a bloomy rind. It has a mild, buttery flavor that intensifies as it ripens. Brie is often enjoyed with crusty bread or fresh fruits.\n",
+       "\n",
+       "5. Manchego: Originating from Spain, Manchego is made from sheep's milk and has a firm, crumbly texture. It has a distinct, nutty flavor with hints of sweetness. Manchego is delicious on its own or paired with quince paste.\n",
+       "\n",
+       "Remember, these are just a few examples of the finest cheeses, and there are countless more varieties to explore. Enjoy your cheese journey!"
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# note the method `to_messages()`, that's what converts our formatted prompt into \n",
+    "formatted_chat_prompt = chat_prompt.format_prompt(SUBJECT=\"cheeses\", MOOD=\"quite tired\", CONTENT=\"Hi, what are the finest cheeses?\").to_messages()\n",
+    "\n",
+    "disp_markdown(chat_model(formatted_chat_prompt).content)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "hHehNFjAXbU_"
+   },
+   "source": [
+    "### Putting the Chain in LangChain\n",
+    "\n",
+    "In essense, a chain is exactly as it sounds - it helps us chain actions together.\n",
+    "\n",
+    "Let's take a look at an example."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 163
+    },
+    "id": "lTzw4ZMoWX0X",
+    "outputId": "ed63bd6c-a682-4a95-fbc8-ad5fc678574f"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/markdown": [
+       "Oh, don't even get me started on the '67 Chevrolet Impala! It's an absolute classic and an iconic vehicle in the world of cars. With its sleek design, powerful engine options, and comfortable interior, it's no wonder why it's so highly regarded among car enthusiasts. Whether you're cruising down the highway or showing it off at a car show, the '67 Impala is sure to turn heads and make a statement. So yes, it is a fantastic vehicle. Now, excuse me while I go calm down."
+      ],
+      "text/plain": [
+       "<IPython.core.display.Markdown object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from langchain.chains import LLMChain\n",
+    "\n",
+    "chain = LLMChain(llm=chat_model, prompt=chat_prompt)\n",
+    "\n",
+    "disp_markdown(chain.run(SUBJECT=\"classic cars\", MOOD=\"angry\", CONTENT=\"Is the 67 Chevrolet Impala a good vehicle?\"))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "Md5XYaAj_t51"
+   },
+   "source": [
+    "### Incorporate A Local Document\n",
+    "\n",
+    "Now that we've got our first chain running, let's talk about how we can leverage our own document!\n",
+    "\n",
+    "First off, we'll need a document!\n",
+    "\n",
+    "For this example, we'll be using Douglas Adam's Hitchker's Guide to the Galaxy - though you can substitute this for any particular document, as long as it's in a text file."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "l4SJNvP_KXk9",
+    "outputId": "d483de62-c84f-4394-f3f5-e07959622562"
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "--2023-09-08 15:57:43--  https://erki.lap.ee/failid/raamatud/guide1.txt\n",
+      "Resolving erki.lap.ee (erki.lap.ee)... 185.158.177.102\n",
+      "Connecting to erki.lap.ee (erki.lap.ee)|185.158.177.102|:443... connected.\n",
+      "HTTP request sent, awaiting response... 200 OK\n",
+      "Length: 291862 (285K) [text/plain]\n",
+      "Saving to: ‘guide1.txt’\n",
+      "\n",
+      "100%[======================================>] 291,862      455KB/s   in 0.6s   \n",
+      "\n",
+      "2023-09-08 15:57:44 (455 KB/s) - ‘guide1.txt’ saved [291862/291862]\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "!wget https://erki.lap.ee/failid/raamatud/guide1.txt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "id": "HX00sL92LATv"
+   },
+   "outputs": [],
+   "source": [
+    "with open(\"guide1.txt\") as f:\n",
+    "    hitchhikersguide = f.read()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "5PdfLcOlKcjH"
+   },
+   "source": [
+    "Next we'll want to split our text into appropirately sized chunks. \n",
+    "\n",
+    "We're going to be using the [CharacterTextSplitter](https://python.langchain.com/docs/modules/data_connection/document_transformers/text_splitters/character_text_splitter) from LangChain today.\n",
+    "\n",
+    "The size of these chunks will depend heavily on a number of factors relating to which LLM you're using, what the max context size is, and more. \n",
+    "\n",
+    "You can also choose to have the chunks overlap to avoid potentially missing any important information between chunks. As we're dealing with a novel - there's not a critical need to include overlap.\n",
+    "\n",
+    "We can also pass in the separator - this is what we'll try and separate the documents on. Be careful to understand your documents so you can be sure you use a valid separator!\n",
+    "\n",
+    "For now, we'll go with 1000 characters. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "id": "BSYNeLXPKZtn"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.text_splitter import CharacterTextSplitter\n",
+    "\n",
+    "text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0, separator = \"\\n\")\n",
+    "texts = text_splitter.split_text(hitchhikersguide)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "z9w-svpbLq62",
+    "outputId": "623c31d3-4676-4dcf-bb41-24df47a7234e"
+   },
+   "outputs": [],
+   "source": [
+    "assert len(texts) == 293"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "dQCXLq-ML_aN"
+   },
+   "source": [
+    "Now that we've split our document into more manageable sized chunks. We'll need to embed those documents!\n",
+    "\n",
+    "For more information on embedding - please check out [this](https://platform.openai.com/docs/guides/embeddings) resource from OpenAI.\n",
+    "\n",
+    "In order to do this, we'll first need to select a method to embed - for this example we'll be using OpenAI's embedding - but you're free to use whatever you'd like. \n",
+    "\n",
+    "You just need to ensure you're using consistent embeddings as they don't play well with others."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "id": "VigAmqxaMd5a"
+   },
+   "outputs": [],
+   "source": [
+    "from langchain.embeddings.openai import OpenAIEmbeddings\n",
+    "\n",
+    "os.environ[\"OPENAI_API_KEY\"] = openai.api_key\n",
+    "\n",
+    "embeddings = OpenAIEmbeddings()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "uEN_IgzqOBNs"
+   },
+   "source": [
+    "Now that we've set up how we want to embed our document - we'll need to embed it. \n",
+    "\n",
+    "For this week we'll be glossing over the technical details of this process - as we'll get more into next week.\n",
+    "\n",
+    "Just know that we're converting our text into an easily queryable format!\n",
+    "\n",
+    "We're going to leverage ChromaDB for this example, so we'll want to install that dependency. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "Y-ZuzHPCOjLc",
+    "outputId": "17641e2c-4838-4785-ddb6-4b14b5b0b3b3"
+   },
+   "outputs": [],
+   "source": [
+    "!pip install chromadb==0.3.22 tiktoken -q "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "id": "ql7jqj7TONDE"
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using embedded DuckDB without persistence: data will be transient\n"
+     ]
+    }
+   ],
+   "source": [
+    "from langchain.vectorstores import Chroma\n",
+    "\n",
+    "docsearch = Chroma.from_texts(texts, embeddings, metadatas=[{\"source\": str(i)} for i in range(len(texts))]).as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "kfn0R64lPb7n"
+   },
+   "source": [
+    "Now that we have our documents embedded we're free to query them with natural language! Let's see this in action!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "id": "ubZwxCHvQzsT"
+   },
+   "outputs": [],
+   "source": [
+    "query = \"What makes towels important?\"\n",
+    "docs = docsearch.get_relevant_documents(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/"
+    },
+    "id": "w4M08F78Q3i3",
+    "outputId": "5364b9ec-b8ce-423a-cbd7-3baabf705bc4"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Document(page_content=\"value - you can wrap it around you for warmth as you bound across\\nthe cold moons of Jaglan Beta; you can lie on it on the brilliant\\nmarble-sanded beaches of Santraginus V, inhaling  the  heady  sea\\nvapours;  you can sleep under it beneath the stars which shine so\\nredly on the desert world of Kakrafoon; use it  to  sail  a  mini\\nraft  down  the slow heavy river Moth; wet it for use in hand-to-\\nhand-combat; wrap it round your head to ward off noxious fumes or\\nto  avoid  the  gaze of the Ravenous Bugblatter Beast of Traal (a\\nmindboggingly stupid animal, it assumes that if you can't see it,\\nit  can't  see  you - daft as a bush, but very ravenous); you can\\nwave your towel in emergencies  as  a  distress  signal,  and  of\\ncourse  dry  yourself  off  with it if it still seems to be clean\\nenough.\\n \\nMore importantly, a towel has immense  psychological  value.  For\\nsome reason, if a strag (strag: non-hitch hiker) discovers that a\\nhitch hiker has his towel with him, he will automatically  assume\", metadata={'source': '36'})"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "-8W9ZmNaRRBX"
+   },
+   "source": [
+    "Finally, we're able to combine what we've done so far into a chain!\n",
+    "\n",
+    "We're going to leverage the `load_qa_chain` to quickly integrate our queryable documents with an LLM.\n",
+    "\n",
+    "There are 4 major methods of building this chain, they can be found [here](https://docs.langchain.com/docs/components/chains/index_related_chains)!\n",
+    "\n",
+    "For this example we'll be using the `stuff` chain type."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "colab": {
+     "base_uri": "https://localhost:8080/",
+     "height": 87
+    },
+    "id": "S7vAWKiFSVj_",
+    "outputId": "2f44bc25-ea96-4c0f-9cc9-8f69c73d913e"
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "' Towels have immense psychological value. For some reason, if a strag discovers that a hitch hiker has his towel with him, he will automatically assume that he is also in possession of a toothbrush, face flannel, soap, tin of biscuits, flask, compass, map, ball of string, gnat spray, wet weather gear, space suit etc., etc. Furthermore, the strag will then happily lend the hitch hiker any of these or a dozen other items that the hitch hiker might accidentally have \"lost\". What the strag will think is that any man who can hitch the length and breadth of the galaxy, rough it, slum it, struggle against terrible odds, win through, and still knows where his towel is is clearly a man to be reckoned with.'"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from langchain.chains.question_answering import load_qa_chain\n",
+    "from langchain.llms import OpenAI\n",
+    "\n",
+    "chain = load_qa_chain(OpenAI(temperature=0), chain_type=\"stuff\")\n",
+    "query = \"What makes towels important?\"\n",
+    "chain.run(input_documents=docs, question=query)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "id": "fMxm7pdwUs5K"
+   },
+   "source": [
+    "Now that we have this set-up, we'll want to package it into an app and pass it to a Hugging Face Space!\n",
+    "\n",
+    "You can find instruction on how to do that in the GitHub Repository!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "colab": {
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "conda_pytorch_p310",
+   "language": "python",
+   "name": "conda_pytorch_p310"
+  },
+  "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}