Upload folder using huggingface_hub

.gitattributes

@@ -33,4 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+JM_QualitativeEvaluationOutput.pdf filter=lfs diff=lfs merge=lfs -text
+JMartinez_OuraAppAssistantReport.pdf filter=lfs diff=lfs merge=lfs -text
 chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text

JM_QualitativeEvaluationOutput.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad4a8d27f639046318b7260e26af6e5ff9760cc68ebebcf33cc575285b95d839
+size 102095

JMartinez_OuraAppAssistantReport.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4e474187cc1a133ac327c587adddff3e9f0fec14bb687ddf9fbf29f54687e57
+size 123984

README.md

@@ -11,3 +11,20 @@ short_description: Specialized LLM for Oura Ring App
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+Reports:
+- JMartinez_OuraAppAssistantReport.pdf
+- JM_QualitativeEvaluationOutput.pdf
+
+Data preparation scripts:
+- extractOuraArticleDataChunks.ipynb
+- extractOuraReddit.ipynb
+
+Knowledge base construction:
+- buildChromaDB.ipynb
+
+Run app assistant notebook:
+- runOuraAppAssistant.ipynb
+
+Gradio deployment:
+- app.py

buildChromaDB.ipynb

@@ -0,0 +1,131 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load Chunks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "\n",
+    "def load_json(file_path):\n",
+    "    with open(file_path, 'r') as file:\n",
+    "        data = json.load(file)\n",
+    "    return data\n",
+    "\n",
+    "file_path = 'oura_article_data_chunked_final.json'\n",
+    "chunks = load_json(file_path)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Init ChromaDB and Embedding Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import chromadb\n",
+    "from chromadb.utils import embedding_functions\n",
+    "\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "# Load a pre-trained sentence embedding model\n",
+    "model = SentenceTransformer(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "\n",
+    "def embedding_func(text):\n",
+    "    return model.encode(text, convert_to_numpy=True)  \n",
+    "\n",
+    "# Initialize ChromaDB (runs locally)\n",
+    "chroma_client = chromadb.PersistentClient(path=\"./chroma_db\") \n",
+    "\n",
+    "# Create or load a collection with metadata support\n",
+    "collection = chroma_client.get_or_create_collection(\n",
+    "    name=\"oura_chunks\",\n",
+    "    metadata={\"hnsw:space\": \"cosine\"}  \n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Add Chunks to ChromaDB"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Insert chunks into ChromaDB\n",
+    "for chunk in tqdm(chunks):\n",
+    "    unique_id = f\"{chunk['article_title'].replace(' ', '_')}_{chunk['chunk_id']}_{chunk['link']}\"  \n",
+    "\n",
+    "    # Check if the embedding ID already exists in the collection\n",
+    "    existing_embedding = collection.get(ids=[unique_id])\n",
+    "\n",
+    "    if existing_embedding[\"documents\"]:\n",
+    "        print(f\"Embedding with ID {unique_id} already exists.\")\n",
+    "    else:\n",
+    "        collection.add(\n",
+    "            ids=[unique_id],  \n",
+    "            embeddings=[embedding_func(chunk[\"chunk\"]).tolist()],  \n",
+    "            documents=[chunk[\"chunk\"]],  \n",
+    "            metadatas=[{\n",
+    "                \"article_title\": chunk[\"article_title\"],\n",
+    "                \"section_title\": chunk[\"section_title\"],\n",
+    "                \"chunk_id\": chunk[\"chunk_id\"],\n",
+    "                \"link\": chunk[\"link\"]\n",
+    "            }]\n",
+    "        )\n",
+    "\n",
+    "print(\"Chunks added successfully!\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ouraDemo",
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

extractOuraArticleDataChunks.ipynb

@@ -0,0 +1,249 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Web Scrape Oura Ring App Content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from selenium import webdriver\n",
+    "from selenium.webdriver.chrome.options import Options\n",
+    "from selenium.webdriver.common.by import By\n",
+    "import time\n",
+    "import re\n",
+    "\n",
+    "# Setup Chrome options\n",
+    "chrome_options = Options()\n",
+    "chrome_options.add_argument(\"--headless\")\n",
+    "chrome_options.add_argument(\"--disable-gpu\")\n",
+    "chrome_options.add_argument(\"--no-sandbox\")\n",
+    "chrome_options.add_argument(\"user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36\")\n",
+    "\n",
+    "# Initialize the WebDriver\n",
+    "driver = webdriver.Chrome(options=chrome_options)\n",
+    "\n",
+    "# Open the main page containing the list of articles\n",
+    "url = \"https://support.ouraring.com/hc/en-us/categories/27782541623059-Oura-App\"\n",
+    "driver.get(url)\n",
+    "time.sleep(3)\n",
+    "\n",
+    "# section_links = [link.get_attribute(\"href\") for link in driver.find_elements(By.XPATH, \"//h3[contains(@class, 'section-tree-title')]/a\")]\n",
+    "section_links = ['https://support.ouraring.com/hc/en-us/sections/9721296007827-App-Settings',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/9721508785171-App-Integrations',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/4415723882003-Readiness',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/4415717595155-Sleep',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/4415723875347-Activity',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/4415730373779-Insights-Reports',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/28332751996435-Heart-Health',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/17984010150803-Women-s-Health',\n",
+    " 'https://support.ouraring.com/hc/en-us/sections/4415723874451-Mindfulness-Meditation']\n",
+    "\n",
+    "articles_data = []\n",
+    "\n",
+    "# Function to split large sections into smaller RAG-friendly chunks\n",
+    "def chunk_text(text, chunk_size=512):\n",
+    "    \n",
+    "    # Split text into sentences and list items\n",
+    "    list_item_pattern = re.compile(r\"^(\\d+\\.\\s+|- )\")  \n",
+    "    lines = text.split(\"\\n\")  \n",
+    "\n",
+    "    chunks = []\n",
+    "    current_chunk = \"\"\n",
+    "\n",
+    "    for line in lines:\n",
+    "        line = line.strip()\n",
+    "        if not line:\n",
+    "            continue  \n",
+    "        \n",
+    "        # Check if this line starts a new list item\n",
+    "        is_list_item = bool(list_item_pattern.match(line))\n",
+    "        \n",
+    "        if is_list_item and current_chunk and len(current_chunk) + len(line) >= chunk_size:\n",
+    "            chunks.append(current_chunk.strip())\n",
+    "            current_chunk = line  \n",
+    "        elif len(current_chunk) + len(line) >= chunk_size:\n",
+    "            chunks.append(current_chunk.strip())\n",
+    "            current_chunk = line  \n",
+    "        else:\n",
+    "            current_chunk += \"\\n\" + line  \n",
+    "    \n",
+    "    if current_chunk:\n",
+    "        chunks.append(current_chunk.strip())  \n",
+    "\n",
+    "    return chunks\n",
+    "\n",
+    "\n",
+    "def extractSectionChunks(driver):\n",
+    "    # Extract article title\n",
+    "    title_element = driver.find_element(By.XPATH, \"//h1[contains(@class, 'article-title')]\")\n",
+    "    article_title = title_element.text if title_element else \"No Title Found\"\n",
+    "\n",
+    "    # Extract all content divs\n",
+    "    content_elements = driver.find_elements(By.XPATH, \"//div[contains(@class, 'article-body')]/*\")\n",
+    "\n",
+    "    chunks = []\n",
+    "    intro_content = []\n",
+    "    current_section = None\n",
+    "    sections = []\n",
+    "    chunk_id = 1  \n",
+    "\n",
+    "    for element in content_elements:\n",
+    "        tag_name = element.tag_name.lower()\n",
+    "        text = element.text.strip()\n",
+    "\n",
+    "        if not text:\n",
+    "            continue  \n",
+    "\n",
+    "        # If a header is encountered, start a new section\n",
+    "        if tag_name in [\"h2\"]:\n",
+    "            # Store previous section\n",
+    "            if current_section:\n",
+    "                sections.append(current_section)\n",
+    "            \n",
+    "            # Start a new section\n",
+    "            current_section = {\"section_title\": text, \"content\": []}\n",
+    "        elif tag_name == \"ol\":\n",
+    "            # Handle ordered (numbered) lists\n",
+    "            list_items = element.find_elements(By.TAG_NAME, \"li\")\n",
+    "            list_text = \"\\n\".join([f\"{idx+1}. {li.text.strip()}\" for idx, li in enumerate(list_items) if li.text.strip()])\n",
+    "            if current_section:\n",
+    "                current_section[\"content\"].append(list_text)\n",
+    "            else:\n",
+    "                intro_content.append(list_text)\n",
+    "        elif tag_name == \"ul\":\n",
+    "            # Handle unordered (bulleted) lists\n",
+    "            list_items = element.find_elements(By.TAG_NAME, \"li\")\n",
+    "            list_text = \"\\n\".join([f\"- {li.text.strip()}\" for li in list_items if li.text.strip()])\n",
+    "            if current_section:\n",
+    "                current_section[\"content\"].append(list_text)\n",
+    "            else:\n",
+    "                intro_content.append(list_text)\n",
+    "        else:\n",
+    "            if current_section:\n",
+    "                current_section[\"content\"].append(text)\n",
+    "            else:\n",
+    "                # This is part of the introduction\n",
+    "                intro_content.append(text)\n",
+    "\n",
+    "    # Store last section\n",
+    "    if current_section:\n",
+    "        sections.append(current_section)\n",
+    "\n",
+    "    # Store introduction **FIRST**\n",
+    "    if intro_content:\n",
+    "        intro_chunks = chunk_text(\"\\n\".join(intro_content))\n",
+    "        for chunk in intro_chunks:\n",
+    "            chunks.append({\n",
+    "                \"article_title\": article_title,\n",
+    "                \"section_title\": \"Introduction\",\n",
+    "                \"chunk\": chunk,\n",
+    "                \"chunk_id\": chunk_id,  \n",
+    "                \"link\": article_link\n",
+    "            })\n",
+    "            chunk_id += 1  \n",
+    "\n",
+    "    # Store all sections\n",
+    "    for section in sections:\n",
+    "        section_chunks = chunk_text(\"\\n\".join(section[\"content\"]))\n",
+    "        for chunk in section_chunks:\n",
+    "            chunks.append({\n",
+    "                \"article_title\": article_title,\n",
+    "                \"section_title\": section[\"section_title\"],\n",
+    "                \"chunk\": chunk,\n",
+    "                \"chunk_id\": chunk_id,  \n",
+    "                \"link\": article_link\n",
+    "            })\n",
+    "            chunk_id += 1  \n",
+    "    return article_title, chunks\n",
+    "\n",
+    "for section_link in section_links:\n",
+    "    driver.get(section_link)\n",
+    "    time.sleep(3)\n",
+    "\n",
+    "    article_links = [link.get_attribute(\"href\") for link in driver.find_elements(By.XPATH, \"//li[contains(@class, 'article-list-item')]/a\")]\n",
+    "\n",
+    "    for article_link in article_links:\n",
+    "        driver.get(article_link)\n",
+    "        time.sleep(3)\n",
+    "\n",
+    "        try:\n",
+    "            article_title,chunks = extractSectionChunks(driver)\n",
+    "            articles_data.extend(chunks)\n",
+    "            print(f\"Extracted: {article_title} - {len(chunks)} chunks\")\n",
+    "        except Exception as e:\n",
+    "            try:\n",
+    "                driver.get(article_link)\n",
+    "                sub_article_links = [link.get_attribute(\"href\") for link in driver.find_elements(By.XPATH, \"//li[contains(@class, 'article-list-item')]/a\")]\n",
+    "                for sub_article_link in sub_article_links:\n",
+    "                    driver.get(sub_article_link)\n",
+    "                    time.sleep(3)\n",
+    "                    article_title,chunks = extractSectionChunks(driver)\n",
+    "                    articles_data.extend(chunks)\n",
+    "                    print(f\"Extracted: {article_title} - {len(chunks)} chunks\")\n",
+    "            except Exception as e:\n",
+    "                print(f\"Failed to extract content from {article_link}: {str(e)}\")\n",
+    "\n",
+    "\n",
+    "driver.quit()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Save Chunks"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "# Save extracted articles to JSON\n",
+    "with open(\"oura_article_data_chunked_final.json\", \"w\", encoding=\"utf-8\") as f:\n",
+    "    json.dump(articles_data, f, indent=4, ensure_ascii=False)\n",
+    "\n",
+    "driver.quit()\n",
+    "\n",
+    "print(\"Scraping complete. Data saved to 'oura_articles.json'\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ouraDemo",
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

extractOuraReddit.ipynb

@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import praw\n",
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "reddit = praw.Reddit(\n",
+    "    client_id=os.getenv(\"REDDIT_CLIENT_ID\"),\n",
+    "    client_secret=os.getenv(\"REDDIT_SECRET\"),\n",
+    "    user_agent=\"OuraBot/1.0\"\n",
+    ")\n",
+    "\n",
+    "# Test connection\n",
+    "print(reddit.read_only)  # Should print True if authentication is successful\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "subreddit = reddit.subreddit(\"ouraring\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from textblob import TextBlob  # For sentiment analysis\n",
+    "import time\n",
+    "\n",
+    "# Function to fetch posts with pagination\n",
+    "def fetch_posts_with_pagination(subreddit, query, limit=100, time_filter='all'):\n",
+    "    posts = []\n",
+    "    after = None\n",
+    "    seen_posts = set()  \n",
+    "    while len(posts) < limit:\n",
+    "        search_results = subreddit.search(query, limit=limit - len(posts), time_filter=time_filter, params={'after': after})\n",
+    "        \n",
+    "        for post in search_results:\n",
+    "            if post.id not in seen_posts:  \n",
+    "                posts.append(post)\n",
+    "                seen_posts.add(post.id)  \n",
+    "            if len(posts) >= limit:\n",
+    "                break  \n",
+    "        \n",
+    "        if not search_results:\n",
+    "            break  \n",
+    "        \n",
+    "        last_post = next(reversed(list(search_results)), None)  \n",
+    "        if last_post:\n",
+    "            after = last_post.fullname  \n",
+    "        time.sleep(1)  \n",
+    "    \n",
+    "    return posts\n",
+    "\n",
+    "\n",
+    "# Function to filter comments based on relevance, upvotes, length, and keywords\n",
+    "def filter_comments(comments, min_upvotes=5, keywords=None, min_length=50, max_length=500):\n",
+    "    filtered_comments = []\n",
+    "    for comment in comments:\n",
+    "        if comment.score < min_upvotes:\n",
+    "            continue\n",
+    "        \n",
+    "        if keywords and not any(keyword.lower() in comment.body.lower() for keyword in keywords):\n",
+    "            continue\n",
+    "        \n",
+    "        comment_length = len(comment.body.split())\n",
+    "        if comment_length < min_length or comment_length > max_length:\n",
+    "            continue\n",
+    "        \n",
+    "        sentiment = TextBlob(comment.body).sentiment.polarity\n",
+    "        if sentiment < 0:  # Only keep positive or neutral comments\n",
+    "            continue\n",
+    "        \n",
+    "        filtered_comments.append(comment)\n",
+    "    \n",
+    "    filtered_comments = sorted(filtered_comments, key=lambda x: x.score, reverse=True)\n",
+    "    return filtered_comments\n",
+    "\n",
+    "\n",
+    "# Define relevant keywords for Oura app support (specific to the app and troubleshooting)\n",
+    "keywords = [\n",
+    "    'fix', 'solution', 'troubleshoot', 'support', 'sync', 'bug', 'pairing', 'error', 'customer service', \n",
+    "    'installation', 'crash', 'not working', 'app issue', 'reset', 'login issue', 'help'\n",
+    "]\n",
+    "\n",
+    "\n",
+    "# Function to determine if a post is high-quality and relevant to Oura app\n",
+    "def is_acceptable_post(post):\n",
+    "    if post.score <= 0 or post.upvote_ratio < 0.6 or post.over_18:\n",
+    "        return False\n",
+    "    \n",
+    "    if post.link_flair_text and \"Support\" not in post.link_flair_text:\n",
+    "        return False\n",
+    "    \n",
+    "    if post.num_comments < 3:\n",
+    "        return False\n",
+    "    \n",
+    "    from datetime import datetime\n",
+    "    if (datetime.utcnow() - datetime.utcfromtimestamp(post.created_utc)).days > 30:\n",
+    "        return False\n",
+    "    \n",
+    "    return True\n",
+    "\n",
+    "# Fetch posts with pagination\n",
+    "subreddit = reddit.subreddit(\"ouraring\")\n",
+    "posts = fetch_posts_with_pagination(subreddit, query, limit=1000, time_filter='all')\n",
+    "\n",
+    "# Process and display the posts and their filtered comments\n",
+    "for post in posts:\n",
+    "    if is_acceptable_post(post): \n",
+    "        print(f\"Post Title: {post.title}\")\n",
+    "        print(f\"Post Link: {post.url}\")\n",
+    "        print(f\"Upvotes: {post.score}\")\n",
+    "\n",
+    "        post.comments.replace_more(limit=0)\n",
+    "        filtered_comments = filter_comments(post.comments, min_upvotes=5, keywords=keywords, min_length=50, max_length=500)\n",
+    "\n",
+    "        for comment in filtered_comments:\n",
+    "            print(f\"  Comment Score: {comment.score}\")\n",
+    "            print(f\"  Comment: {comment.body}\\n\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ouraDemo",
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

runOuraAppAssistant.ipynb

@@ -0,0 +1,248 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Run the Oura App Assistant"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Here, we retrieve the most relevant chunks based on the user's query and incorporate into a prompt sent to the LLM for a response."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ollama\n",
+    "from openai import OpenAI\n",
+    "import chromadb\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
+    "\n",
+    "# Use a basic sentence transformer finetuned for text similarity tasks\n",
+    "model = SentenceTransformer(\"sentence-transformers/all-MiniLM-L6-v2\")\n",
+    "\n",
+    "ollama.pull(\"mistral\")\n",
+    "\n",
+    "def embedding_func(text):\n",
+    "    return model.encode(text, convert_to_numpy=True)  \n",
+    "\n",
+    "# Initialize ChromaDB (runs locally)\n",
+    "chroma_client = chromadb.PersistentClient(path=\"./chroma_db\")  \n",
+    "\n",
+    "# Create or load a collection with metadata support\n",
+    "collection = chroma_client.get_or_create_collection(\n",
+    "    name=\"oura_chunks\",\n",
+    "    metadata={\"hnsw:space\": \"cosine\"}  \n",
+    ")\n",
+    "\n",
+    "# Initialize LLM (Ollama Mistral model)\n",
+    "def query_ollama(query, context):\n",
+    "    # Construct prompt with instructions, context, and query\n",
+    "    prompt = (\n",
+    "    \"You are an expert assistant answering questions about the Oura Ring app.\\n\"\n",
+    "    \"Based on the following context, please answer the user's question.\\n\"\n",
+    "    \"Only use the provided context for your response. If you cannot find a relevant answer, state that the query is out of scope.\\n\"\n",
+    "    \"Cite the most relevant article, section, and link that are directly found in the provided context.\\n\"\n",
+    "    \"Do not provide links that are not found in the provided context.\\n\\n\"\n",
+    "    f\"{context}\\n\\n\"\n",
+    "    f\"User's Question: {query}\"\n",
+    "    )\n",
+    "    # Submit prompt and get response\n",
+    "    response = ollama.chat(model=\"mistral\", messages=[{\"role\": \"user\", \"content\": prompt}])\n",
+    "    return response[\"message\"][\"content\"]\n",
+    "\n",
+    "def query_openai(query, context):\n",
+    "    client = OpenAI(api_key=os.getenv(\"OPENAI_API_KEY\"))\n",
+    "\n",
+    "    # Add instructions to the system message\n",
+    "    system_message = {\"role\": \"system\", \n",
+    "        \"content\": \"You are an expert assistant answering questions about the Oura Ring app.\\n\"\n",
+    "        \"Use only the provided context for your responses.\\n\"\n",
+    "        \"If you do not find relevant information, clearly state that the question is out of scope.\\n\"\n",
+    "        \"Always cite the most relevant article, section, and link that are directly found in the provided context.\\n\"\n",
+    "        \"Do not provide links that are not found in the provided context.\"}\n",
+    "    \n",
+    "    # Add the user's input\n",
+    "    user_message = {\"role\": \"user\", \"content\": query}\n",
+    "\n",
+    "    # Submit system message for response\n",
+    "    completion = client.chat.completions.create(\n",
+    "        model=\"gpt-4\",  \n",
+    "        messages=[\n",
+    "            system_message,  \n",
+    "            {\"role\": \"assistant\", \"content\": context},  \n",
+    "            user_message  \n",
+    "        ],\n",
+    "    )\n",
+    "    \n",
+    "    # Output the chatbot's response\n",
+    "    return completion.choices[0].message.content\n",
+    "\n",
+    "# Query ChromaDB for relevant chunks\n",
+    "def retrieve_relevant_chunks(query, n_results=5):\n",
+    "    query_embedding = embedding_func(query).tolist()  \n",
+    "    results = collection.query(\n",
+    "        query_embeddings=[query_embedding], \n",
+    "        n_results=n_results\n",
+    "    )\n",
+    "    return results\n",
+    "\n",
+    "# Perform RAG (Retrieve + Generate) with Ollama/OpenAI\n",
+    "def perform_rag(query, provider=\"ollama\"):\n",
+    "    # Retrieve relevant chunks from ChromaDB\n",
+    "    results = retrieve_relevant_chunks(query, n_results=5)\n",
+    "    \n",
+    "    # Combine the retrieved chunks for LLM input\n",
+    "    relevant_chunks = []\n",
+    "    for document, metadata, distance in zip(results[\"documents\"][0],results[\"metadatas\"][0],results[\"distances\"][0]):\n",
+    "        # Apply relatively lenient filter to return most relevant chunks\n",
+    "        if distance > 0.75:\n",
+    "            continue\n",
+    "        # Structure chunks to include all relevant metadata\n",
+    "        relevant_chunks.append(f'\\nArticle Title: {metadata[\"article_title\"]}\\nSection Title: {metadata[\"section_title\"]}\\nArticle Link: {metadata[\"link\"]}\\nRelevance Score: {100*round(1 - distance, 2)}\\nArticle Content: {document}\\n')\n",
+    "    if len(relevant_chunks) < 1:\n",
+    "        context = f'\\nArticle Title: No Relevant Article\\nSection Title: No Relevant Article\\nArticle Link: No Relevant Article\\nRelevance Score: No Relevant Article\\nArticle Content: No Relevant Article\\n'\n",
+    "    else:\n",
+    "        context = \"\\n\".join(relevant_chunks)  \n",
+    "\n",
+    "    if provider == \"ollama\":\n",
+    "        # Query Ollama Mistral for a response\n",
+    "        answer = query_ollama(query, context)\n",
+    "    elif provider == \"openai\":\n",
+    "        # Query OpenAI gpt-4 for a response\n",
+    "        answer = query_openai(query, context)\n",
+    "    else:\n",
+    "        print(\"Invalid ChatBot provider, please select either ollama or openai!\")\n",
+    "    \n",
+    "    return answer\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Qualitative Evaluation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For the qualitative evaluation, I provide each model with three sets of queries: 1) Relevant Queries, 2) Non-Relevant Queries, 3) Troubleshooting Queries, and 4) Subjective Queries. These queries highlight the model's ability to correctly answer questions relevant to the Oura app, identify when the question is out of scope, provide some coaching for troubleshooting and summarize subjective queries about the Oura App. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "providers = {\"Ollama (Mistral) Evaluation\": \"ollama\", \n",
+    "          \"Open AI (gpt-4) Evaluation\": \"openai\"}\n",
+    "query_types = {\"Relevant Queries\": [\n",
+    "\"How can I set the language for the Oura App?\",\n",
+    "\"Does the Oura App provide information about sleep quality?\"],\n",
+    "\"Non-Relevant Queries\": [\"How can I order a hamburger?\",\n",
+    "                        \"How can I order an Oura ring for my dog?\"],\n",
+    "\"Troubleshooting Queries\": [\"What should I do if my Oura Ring is not syncing with the Oura App?\",\n",
+    "                           \"What should I do if my Oura Ring is not syncing with Apple Health?\"],\n",
+    "\"Subjective Queries\": [\"Do users generally prefer the Oura App instead of the Apple Health App?\"]}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "for provider in providers.keys():\n",
+    "    print(\"================================================================================\")\n",
+    "    print(provider)\n",
+    "    for query_type in query_types.keys():\n",
+    "        print(f\"********************** {query_type} **********************\")\n",
+    "        for idx,question in enumerate(query_types[query_type]):\n",
+    "            print(\"------------------------------------------------------------\")\n",
+    "            answer = perform_rag(question, providers[provider])\n",
+    "            output_string = f\"{idx+1}) Question: {question}\\nAnswer: {answer}\\n\\n\"\n",
+    "            print(output_string)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Local Deployment to Gradio"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import gradio as gr\n",
+    "\n",
+    "def ask_oura_assistant(user_input, provider):\n",
+    "    if \"ollama\" in provider.lower():\n",
+    "        return perform_rag(user_input, \"ollama\")\n",
+    "    elif \"openai\" in provider.lower():\n",
+    "        return perform_rag(user_input, \"openai\")\n",
+    "\n",
+    "demo = gr.Interface(\n",
+    "    fn=ask_oura_assistant, \n",
+    "    inputs=[\n",
+    "        gr.Textbox(label=\"Ask a question...\"),  \n",
+    "        gr.Dropdown([\"OpenAI (gpt-4)\", \"Ollama (Mistral)\"], label=\"Select Provider\")  \n",
+    "    ],\n",
+    "    outputs=\"text\",  \n",
+    "    title=\"Oura Ring App Assistant\",\n",
+    "    description=\"Ask me anything about the Oura Ring app! Select your provider before submitting.\")\n",
+    "\n",
+    "demo.launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ouraDemo",
+   "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.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}