qna-quickstart-template/qna-app-quickstart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Azure OpenAI Service - Q&A with semantic answering Quickstart app\n",
    "\n",
    "This notebook helps you to build a simple Q&A demo application by doing the following steps\n",
    "\n",
    "1. Data preparation - you will need to adapt this code to have it work with your data\n",
    "1. Embedding creation - this will mostly work out of the box\n",
    "1. Prompt creation - this will mostly work out of the box, but you could adapt this a little bit\n",
    "1. App creation - this will mostly work out of the box, but you can make changes if needed\n",
    "\n",
    "Firstly, create a file called `.env` in this folder, and add the following content, obviously with your values:\n",
    "\n",
    "```\n",
    "OPENAI_API_KEY=xxxxxx\n",
    "OPENAI_API_BASE=https://xxxxxxx.openai.azure.com/\n",
    "```\n",
    "\n",
    "Then, let's install all dependencies:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import json\n",
    "import tiktoken\n",
    "import openai\n",
    "import numpy as np\n",
    "import pickle\n",
    "from dotenv import load_dotenv\n",
    "from openai.embeddings_utils import cosine_similarity\n",
    "from tenacity import retry, wait_random_exponential, stop_after_attempt\n",
    "\n",
    "# Load environment variables\n",
    "load_dotenv()\n",
    "\n",
    "# Configure OpenAI API\n",
    "openai.api_type = \"azure\"\n",
    "openai.api_version = \"2022-12-01\"\n",
    "openai.api_base = os.getenv('OPENAI_API_BASE')\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "# Define embedding model and encoding\n",
    "EMBEDDING_MODEL = 'text-embedding-ada-002'\n",
    "EMBEDDING_ENCODING = 'cl100k_base'\n",
    "EMBEDDING_CHUNK_SIZE = 8000\n",
    "COMPLETION_MODEL = 'text-davinci-003'\n",
    "\n",
    "# initialize tiktoken for encoding text\n",
    "encoding = tiktoken.get_encoding(EMBEDDING_ENCODING)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data preparation\n",
    "\n",
    "Adapt this code to read in our data, the output should be an Python array with dicts inside, containing the keys filename, text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list all files in the data\n",
    "data_dir = os.path.join(os.getcwd(), \"data/\")\n",
    "files = os.listdir(data_dir)\n",
    "\n",
    "# read content from each file and append it to documents\n",
    "documents = []\n",
    "for file in files:\n",
    "    with open(os.path.join(data_dir, file), \"r\") as f:\n",
    "        # read the content from the txt file\n",
    "        content = f.read()\n",
    "        documents.append({\n",
    "            \"filename\": file,\n",
    "            \"content\": content,\n",
    "        })\n",
    "\n",
    "# print some stats about the documents\n",
    "print(f\"Loaded {len(documents)} documents\")\n",
    "for doc in documents:\n",
    "    num_tokens = len(encoding.encode(doc['content']))\n",
    "    print(f\"Filename: {doc['filename']} Content: {doc['content'][:80]}... \\n---> Tokens: {num_tokens}\\n\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create the function to embed a single document:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))\n",
    "def get_embedding(text):\n",
    "    # remove newlines and double spaces\n",
    "    text = text.replace(\"\\n\", \" \").replace(\"  \", \" \")\n",
    "    return openai.Embedding.create(input=text, engine=EMBEDDING_MODEL)[\"data\"][0][\"embedding\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create embeddings for all docs\n",
    "for doc in documents:\n",
    "    doc['embedding'] = get_embedding(doc['content'])\n",
    "    print(f\"Created embedding for {doc['filename']}\")\n",
    "    \n",
    "# Save documents to disk\n",
    "pickle.dump(documents, open(\"documents.pkl\", \"wb\"))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's write our app template, feel free to change the title, etc.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting ./app.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile ./app.py\n",
    "\n",
    "import os\n",
    "import openai\n",
    "import streamlit as st\n",
    "import tiktoken\n",
    "import numpy as np\n",
    "import pickle\n",
    "from openai.embeddings_utils import cosine_similarity\n",
    "from dotenv import load_dotenv\n",
    "from tenacity import retry, wait_random_exponential, stop_after_attempt\n",
    "\n",
    "# Load environment variables\n",
    "load_dotenv()\n",
    "\n",
    "# Configure OpenAI API\n",
    "openai.api_type = \"azure\"\n",
    "openai.api_version = \"2022-12-01\"\n",
    "openai.api_base = os.getenv('OPENAI_API_BASE')\n",
    "openai.api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "COMPLETION_MODEL = 'text-davinci-003'\n",
    "EMBEDDING_MODEL = 'text-embedding-ada-002'\n",
    "\n",
    "documents = pickle.load(open(\"documents.pkl\", \"rb\"))\n",
    "\n",
    "@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(6))\n",
    "def get_embedding(text):\n",
    "    # remove newlines and double spaces\n",
    "    text = text.replace(\"\\n\", \" \").replace(\"  \", \" \")\n",
    "    return openai.Embedding.create(input=text, engine=EMBEDDING_MODEL)[\"data\"][0][\"embedding\"]\n",
    "\n",
    "@retry(wait=wait_random_exponential(min=1, max=20), stop=stop_after_attempt(10))\n",
    "def run_prompt(prompt, max_tokens=1000):\n",
    "    response = openai.Completion.create(\n",
    "        engine=COMPLETION_MODEL,\n",
    "        prompt=prompt,\n",
    "        temperature=0.7,\n",
    "        max_tokens=max_tokens\n",
    "    )\n",
    "    return response['choices'][0]['text']\n",
    "\n",
    "# configure UI elements with Streamlit\n",
    "\n",
    "st.title('Demo app')\n",
    "question = st.text_input('Question')\n",
    "answer_button = st.button('Generate answer')\n",
    "\n",
    "if answer_button:\n",
    "    # first extract the actual search query from the question\n",
    "    question_prompt = f\"\"\"You extract search queries from prompts and remove all styling options or other things (e.g., the formatting the user asks for). You do not answer the question.\n",
    "Prompt: {question}\\n\n",
    "Query:\"\"\"\n",
    "    search_query = run_prompt(question_prompt, max_tokens=100)\n",
    "    \n",
    "    # then get the embedding and compare it to all documents\n",
    "    qe = get_embedding(search_query)\n",
    "    similarities = [cosine_similarity(qe, doc['embedding']) for doc in documents]\n",
    "    max_i = np.argmax(similarities)\n",
    "\n",
    "    st.write(f\"**Searching for:** {search_query}\\n\\n**Found answer in:** {documents[max_i]['filename']}\")\n",
    "\n",
    "    # finally generate the answer\n",
    "    prompt = f\"\"\"\n",
    "    Content:\n",
    "    {documents[max_i]['content']}\n",
    "    Please answer the question below using only the content from above. If you don't know the answer or can't find it, say \"I couldn't find the answer\".\n",
    "    Question: {question}\n",
    "    Answer:\"\"\"\n",
    "    answer = run_prompt(prompt)\n",
    "\n",
    "    st.write(f\"**Answer**:\\n\\n{answer}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, run the app:\n",
    "\n",
    "```\n",
    "streamlit run app.py\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "openai-qna-env",
   "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.9"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c4ee1bbf3137c7ea9420c4fd488a55642063e5739fe2a7286130d9ba47405b69"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}