first commit

.env

@@ -0,0 +1,3 @@
+OPENAI_API_KEY=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
+PINECONE_API_KEY=5207f7a8-e003-4610-8adb-367ac66812d4
+MONGO_URI=mongodb+srv://jandrade2018:[email protected]/?retryWrites=true&w=majority

Dockerfile

@@ -0,0 +1,78 @@
+# Use the base Python image
+FROM python:3.9
+
+# Set up a new user named "user" with user ID 1000
+# This creates a new user within the Docker container with user ID 1000.
+RUN useradd -m -u 1000 user
+
+# Overrides permissions for Hugging Face Docker.
+# Switches to the newly created user to run subsequent commands, enhancing security.
+USER user
+
+# Set environment variables for the user's home directory and executable path
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to /home/user/app
+WORKDIR $HOME/app
+
+# Install Python dependencies first to avoid reinstalling on code changes
+# Copy the requirements.txt file into the container and install dependencies.
+COPY ./requirements.txt $HOME/app/requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt \
+    && pip install --no-cache-dir --upgrade pymongo
+
+
+# Switch back to root to install system dependencies
+USER root
+
+# Install system dependencies
+RUN apt-get update \
+    && apt-get install -y ffmpeg python3-pyaudio portaudio19-dev \
+    && apt-get clean
+
+# Switch back to the user
+USER user
+
+# Expose the secret OPENAI_API_KEY at buildtime and use its value as an environment variable
+RUN --mount=type=secret,id=OPENAI_API_KEY,mode=0444,required=true \
+    echo "export OPENAI_API_KEY=$(cat /run/secrets/OPENAI_API_KEY)" >> /home/user/app/.env
+
+RUN --mount=type=secret,id=PINECONE_API_KEY,mode=0444,required=true \
+    echo "export PINECONE_API_KEY=$(cat /run/secrets/PINECONE_API_KEY)" >> /home/user/app/.env
+
+RUN --mount=type=secret,id=MONGO_URI,mode=0444,required=true \
+    echo "export MONGO_URI=$(cat /run/secrets/MONGO_URI)" >> /home/user/app/.env
+
+# Source the .env file to set environment variables
+RUN echo "source $HOME/app/.env" >> $HOME/.bashrc
+
+# Copy the rest of the application into the container
+# This includes your Python scripts, models, and any other necessary files.
+COPY --chown=user . $HOME/app
+
+
+# Specify the command to run when the container starts
+# Here, it runs the "app.py" script using the Python interpreter.
+CMD ["python", "app.py"]
+
+# --------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+# Overview 
+
+# This Dockerfile is used to build a Docker image for a Python application. 
+# It starts with the official Python 3.9 image as a base. 
+# It then sets up a new user, switches to that user for security reasons, and defines environment variables. 
+# The working directory is set to "/home/user/app," where Python dependencies are installed from the "requirements.txt" file. 
+# The entire application is copied into the container. 
+# Finally, the CMD directive specifies that the "app.py" script should run when the container starts.
+
+# Architecture:
+
+# In the context of Hugging Face Docker Spaces, this Docker image encapsulates your Python application, 
+# ensuring that it runs consistently across different environments (linus, macOS, windows, etc). 
+# Docker containers provide a lightweight and isolated environment for applications, enhancing portability and reproducibility. 
+# The use of a non-root user and defined environment variables contributes to security best practices. 
+# The "CMD" instruction specifies the default behavior of the container.
+
+

README.md

@@ -1,10 +1,130 @@
 ---
-title: FirstAid Bot
-emoji: 🌍
-colorFrom: indigo
-colorTo: yellow
+title: First-Aid Bot
+emoji: 🐳
+colorFrom: purple
+colorTo: gray
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# -------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+title: Basic Docker SDK Space
+# Basic Docker SDK Space Configuration
+# Describes the title or name of your Docker Space.
+# Helps identify and provide a quick overview of the purpose or content of your Space.
+
+emoji: 🐳
+# Adds an emoji character to your title for visual representation.
+# Emojis can add a creative touch and quickly convey the theme or essence of your Space.
+
+colorFrom: purple
+# Defines a gradient color scheme for the Space thumbnail.
+# colorFrom sets the starting color of the gradient (purple).
+
+colorTo: gray
+# colorTo sets the ending color of the gradient (gray).
+
+sdk: docker
+# Specifies the software development kit (SDK) or runtime environment for your Space.
+# Here, it is set to "docker," indicating that this Space is configured to work with Docker.
+# It defines the underlying technology used to run and manage your application.
+
+app_port: 7860
+# Specifies the port through which your application will be accessible.
+# This is the port that will be exposed for users to interact with your application when deployed in a Docker Space.
+# app_port: Exposes this port of the app
+
+# code up top is a README.md file's YAML block.
+# You can change the default exposed port 7860
+
+# Docker Spaces for Your Custom Applications
+
+# -------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+<!-- Introduction to Docker Spaces -->
+Unlock the full potential of your custom applications by harnessing the flexibility of Docker Spaces. Docker Spaces provide a versatile environment for running apps that go beyond the conventional capabilities of Streamlit and Gradio. Whether you're developing FastAPI, Go endpoints, Phoenix apps, or robust ML Ops tools, Docker Spaces empower you to craft solutions tailored to your unique needs.
+
+## Setting Up Your Docker Space
+
+<!-- Explanation for setting up Docker Spaces -->
+To initialize your Space with Docker, make sure to select Docker as the SDK when creating a new Space. This is done by setting the `sdk` property to `docker` in the YAML block of your README.md file.
+
+# Exposing Your Application Port
+
+<!-- Explanation for exposing the application port -->
+By setting `app_port: 7860`, you're specifying the port through which your application inside the Docker container will be accessible. This port is exposed externally, allowing users to interact with your application using this port when the Docker Space is deployed.
+
+# Docker Behind the Scenes
+
+<!-- Overview of Docker architecture and purpose -->
+## Overview:
+
+This Dockerfile is used to build a Docker image for a Python application. It starts with the official Python 3.9 image as a base. It then sets up a new user, switches to that user for security reasons, and defines environment variables. The working directory is set to "/home/user/app," where Python dependencies are installed from the "requirements.txt" file. The entire application is copied into the container. Finally, the CMD directive specifies that the "app.py" script should run when the container starts.
+
+## Architecture:
+
+In the context of Hugging Face Docker Spaces, this Docker image encapsulates your Python application, ensuring that it runs consistently across different environments. Docker containers provide a lightweight and isolated environment for applications, enhancing portability and reproducibility. The use of a non-root user and defined environment variables contributes to security best practices. The "CMD" instruction specifies the default behavior of the container.
+
+## Why Containers:
+
+Containers, like Docker, package applications and their dependencies, providing a consistent and reproducible environment. This facilitates seamless deployment across various systems, reducing compatibility issues. Containers isolate applications, preventing conflicts with the underlying infrastructure, making them a popular choice for deploying and managing applications in production.
+
+# -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+# Visual Representation of Architecture:
+
+This diagram represents the sequential steps in building a Docker image for the Python application. Each box indicates a distinct operation or instruction in the Dockerfile, and arrows depict the flow of these operations. The image starts with an official Python 3.9 base, and each subsequent step contributes to setting up the environment, installing dependencies, and defining the behavior when the container starts.
+
+
+
+# Docker Image Build Process
+
+Base Image: python:3.9
+|
+└── Set up user "user" with ID 1000
+|
+└── Define environment variables (HOME, PATH)
+|
+└── Set working directory to /home/user/app
+|   |
+|   └── Copy requirements.txt into /home/user/app
+|   |
+|   └── Install Python dependencies from requirements.txt
+|
+└── Copy entire application into /home/user/app
+|
+└── CMD ["python", "app.py"]
+
+# Docker Container Runtime Process
+
+Docker Container:
+|
+└── Python Application
+|   |
+|   └── Gradio with default port 7860
+|   └── FastAPI, OpenAI, and other dependencies
+|
+└── Exposed Port: 7860
+|
+└── Running "app.py" script
+
+# Port Mapping Explanation:
+
+When dealing with Docker containers and applications like Gradio, it's essential to understand how ports work. In simple terms, a port is like a designated entrance at a busy airport.
+
+In this scenario:
+- The Gradio application inside your Docker container is like an airport terminal.
+- The Gradio application uses Port 7860 as its entrance gate, allowing data to flow in and out.
+
+Now, Docker acts like a traffic controller, managing the flow of data between your computer and the Gradio application inside the container.
+
+Here's the breakdown:
+- Your computer communicates with the Docker container through a specific port.
+- Think of it as your boarding pass, guiding your data to the correct entrance (Port 7860) of the Gradio application.
+
+So, when you expose Port 7860 in your Docker Space configuration (README.md), you're essentially saying, "Hey, users, when you want to interact with my application, use Port 7860 as the entrance gate."
+
+In conclusion, it's a way to ensure smooth communication between your computer and the Gradio application running inside the Docker container, allowing you to access and interact with the application seamlessly.
+
+

app.py

@@ -0,0 +1,345 @@
+import os
+import re
+import openai
+import pinecone
+import requests
+import gradio as gr
+from gtts import gTTS
+from dotenv import load_dotenv
+from langchain.llms import OpenAI
+from langchain import PromptTemplate
+from langchain.vectorstores import Chroma
+from requests.exceptions import JSONDecodeError
+from transformers import AutoTokenizer, AutoModel
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.chains import RetrievalQA, LLMChain
+from langchain.document_loaders import TextLoader, DirectoryLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Initialize Pinecone with API key
+pinecone.init(api_key="5207f7a8-e003-4610-8adb-367ac66812d4", environment='gcp-starter')
+index_name = "clinical-bert-index"
+
+# Create a vector database that stores medical knowledge
+loader = DirectoryLoader('./medical_data/', glob="./*.txt", loader_cls=TextLoader)
+documents = loader.load()
+
+# Split documents into texts
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+texts = text_splitter.split_documents(documents)
+
+# Initialize Vectordb
+persist_directory = 'db'
+embedding = OpenAIEmbeddings()
+vectordb = Chroma.from_documents(documents=texts, embedding=embedding, persist_directory=persist_directory)
+vectordb.persist()
+
+# Create a retrieval QA chain using the vector database as its retriever
+retriever = vectordb.as_retriever()
+docs = retriever.get_relevant_documents("For Cuts and Scrapes ")
+retriever = vectordb.as_retriever(search_kwargs={"k": 2})
+
+# Specify the template that the LLM will use to generate its responses
+bot_template = '''I want you to act as a medicine advisor for people. 
+Explain in simple words how to treat a {medical_complication}'''
+
+tokenizer = AutoTokenizer.from_pretrained("medicalai/ClinicalBERT")
+model = AutoModel.from_pretrained("medicalai/ClinicalBERT")
+model_path = "medicalai/ClinicalBERT"
+tokenizer_str = tokenizer.__class__.__name__ 
+
+# Create Prompt
+prompt = PromptTemplate(
+    input_variables=['medical_complication'],
+    template=bot_template 
+)
+
+# Specify the LLM that you want to use as the language model
+llm = OpenAI(temperature=0.8)
+chain1 = LLMChain(llm=llm, prompt=prompt)
+
+# Create the retrieval QA chain
+qa_chain = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever, return_source_documents=True)
+
+# Global variables
+global_filepath = None
+global_feedback = None
+chatgpt_response = ""
+modMed_response = ""
+trigger_words = ""
+
+
+def preprocess_text(text):
+    # Preprocess the input text
+    text = text.lower()
+    text = re.sub(r"[^a-zA-Z0-9\s]", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+        embeddings = outputs.last_hidden_state
+
+    embeddings_list = embeddings.squeeze().tolist()
+    embeddings_array = embeddings.squeeze().numpy()
+
+    reducer = umap.UMAP(n_components=768)
+    reduced_embeddings = reducer.fit_transform(embeddings_array)
+
+    return reduced_embeddings
+
+
+# API key for OpenAI
+my_key = os.getenv("OPENAI_API_KEY")
+openai.api_key = my_key
+
+# Initialize Pinecone index
+pinecone_index = pinecone.Index(index_name=index_name)
+
+# Define function to retrieve embeddings from Pinecone
+def retrieve_embeddings_from_pinecone(query):
+    results = pinecone_index.query(
+        vector=query,
+        top_k=3,
+        include_values=True
+    )
+    retrieved_embeddings = results[0].vectors
+    return retrieved_embeddings
+
+
+# Function to process user input
+def process_user_input(audio_filepath, feedback):
+    global global_filepath
+    audio = open(audio_filepath, "rb")
+    global_filepath = audio_filepath
+
+    transcript = openai.Audio.transcribe("whisper-1", audio)
+
+    return transcript["text"]
+
+
+# Function to find trigger words
+def findTriggerWords(user_input):
+    prompt = (
+        f"Given this user input: {user_input}\n"
+        "Task: Identify and return important keywords from the user input. "
+        "These keywords are crucial for understanding the user's intent and finding a relevant solution. "
+        "Consider context and relevance. Provide a numbered list up to 5 keywords or less"
+    )
+
+    response = openai.Completion.create(
+        model="text-davinci-003", 
+        prompt=prompt,
+        max_tokens=500, 
+        temperature=0.7,  
+    )
+
+    ChatGPT_response = response['choices'][0]['text']
+    return ChatGPT_response.replace(".", "").replace("\n", "", 1).strip()
+
+
+# Function to make an API call
+def api_call(url):
+    try:
+        response = requests.post(url)
+        if response.status_code == 200:
+            updated_data = response.json()
+            print(f"Updated Database: {updated_data}")
+            return updated_data
+        else:
+            print(f"Error updating database: {response.status_code}")
+            print(response.text)
+            return None
+    except JSONDecodeError as e:
+        print(f"JSONDecodeError: {e}")
+        print(f"Response text: {response.text}")
+        return None
+
+
+# Function to process feedback
+def process_feedback(feedback, current_filepath):
+    global global_filepath, global_feedback, chatgpt_response, modMed_response
+    ans = ""
+    url = ""
+    backend_url = "https://iq4aas9gc2.execute-api.us-east-2.amazonaws.com/default/test/"
+
+    if feedback in ["🏥 ModMed", "🤖 ChatGPT"] and global_feedback == None:
+        global_feedback = feedback
+        incr_query_string = ''.join(char for char in feedback if char.isalnum())
+        url = f"{backend_url}increment_likes/{incr_query_string}"
+        print("new audio file")
+
+    elif feedback in ["🏥 ModMed", "🤖 ChatGPT"] and global_feedback != None:
+        print("same audio file, different radio button")
+        global_feedback = feedback
+        decr_query_string = ''.join(char for char in global_feedback if char.isalnum())
+        incr_query_string = ''.join(char for char in feedback if char.isalnum())
+        decrement_url = f"{backend_url}decrement_likes/{decr_query_string}"
+        increment_url = f"{backend_url}increment_likes/{incr_query_string}"
+
+        # Decrement likes
+        decrement_data = api_call(decrement_url)
+
+        if decrement_data:
+            # Increment likes if decrement was successful
+            url = increment_url
+
+    else:
+        return ans
+
+    updated_data = api_call(url)
+
+    if updated_data:
+        if feedback == "🏥 ModMed":
+            chatgpt_response = ""
+            modMed_response = "True"
+        elif feedback == "🤖 ChatGPT":
+            modMed_response = ""
+            chatgpt_response = "True"
+
+        preferred_strings = ", ".join(string for string in ["ModMed", "ChatGPT"] if string != incr_query_string)
+        ans = f"{updated_data['Likes']}/{updated_data['TotalLikes']} People preferred {incr_query_string} over {preferred_strings}.\nThank you! 👍"
+
+    return ans
+
+
+# Function to handle the chatbot logic
+def chatbot(microphone_filepath, upload_filepath, feedback):
+    global global_filepath, global_feedback, chatgpt_response, modMed_response, trigger_words
+    print("Feedback", feedback)
+    
+    if microphone_filepath is not None:
+        audio_filepath = microphone_filepath
+    elif upload_filepath is not None:
+        audio_filepath = upload_filepath
+    else:
+        global_filepath = global_feedback = None
+        chatgpt_response = ""
+        modMed_response = ""
+        trigger_words = ""
+        print(trigger_words)
+        global_filepath = None
+        global_feedback = None
+        return None, None, None, None, None        
+
+    # Process user input
+    if global_filepath != audio_filepath:
+        user_input = process_user_input(audio_filepath, feedback)
+        trigger_words = findTriggerWords(user_input)
+    elif feedback == "Clear" and global_filepath != None:
+        feedback = ""
+        chatgpt_response = ""
+        modMed_response = ""
+        trigger_words = ""
+        global_filepath = None
+        global_feedback = None
+        return None, None, None, None, None
+    else:
+        user_input = None
+
+    if user_input is not None or feedback != global_feedback:
+        # Get the chatbot response
+        chatgpt_prompt = f"Act like a medical bot and return at most 5 sentences if the user_input isn't a medical question then answer the question in general: user_input:\n{user_input}"
+        llm_response = qa_chain(chatgpt_prompt)
+        prompt_response = chain1(user_input)
+        
+        f_modMed_response, f_chatgpt_response = process_llm_response(llm_response, prompt_response)
+        ans = process_feedback(feedback, global_filepath)
+
+        if modMed_response  == "" and chatgpt_response != "": 
+            print("CHATGPT FEEDBACK")
+            clean_response = f_chatgpt_response.split('<br>')[0]
+            audio_response = text_to_speech(clean_response) 
+            return gr.make_waveform(audio_response, animate=True), None, f_chatgpt_response, trigger_words, ans 
+
+        elif modMed_response  != "" and chatgpt_response == "": 
+            print("MODMED FEEDBACK")
+            clean_response = f_modMed_response.split('<br>')[0]
+            audio_response = text_to_speech(clean_response) 
+            return gr.make_waveform(audio_response, animate=True), f_modMed_response, None, trigger_words, ans 
+        else:
+            print("NO FEEDBACK")
+            audio_response = text_to_speech(f_modMed_response.split('<br>')[0])
+            return gr.make_waveform(audio_response, animate=True), f_modMed_response, f_chatgpt_response, trigger_words, ans
+    
+    return None, None, None, None, None
+
+
+def process_llm_response(llm_response, prompt_response):
+    ChatGPT_response = llm_response['result']
+    ModMed_response = str(prompt_response["text"])
+
+    ChatGPT_image_html = f'<img src="https://static.vecteezy.com/system/resources/previews/021/495/996/original/chatgpt-openai-logo-icon-free-png.png" alt="image" style="width:25px;height:25px;display:inline-block;">'
+    ModMed_image_html = f'<img src="https://png.pngtree.com/png-clipart/20230707/original/pngtree-green-approved-stamp-with-check-mark-symbol-vector-png-image_9271227.png" alt="image" style="width:25px;height:25px;display:inline-block;">'
+    
+    ModMed_source = f'<br><span style="color: darkgray;">ModMedicine Certified {ModMed_image_html}</span>'
+    ChatGPT_source = f'<br><span style="color: darkgray;">ChatGPT {ChatGPT_image_html}</span>'
+
+    return (
+        ModMed_response + ModMed_source,
+        ChatGPT_response + ChatGPT_source
+    )
+
+
+def play_response(response=None):
+    if response is not None:
+        audio_path = text_to_speech(response)
+        return gr.Audio(audio_path)
+    else:
+        return None
+
+
+def text_to_speech(text):
+    # Find the index of 'ModMed Certified' (case insensitive)
+    certified_index = text.lower().find('ModMedicine certified')
+    chatgpt_index = text.lower().find('ChatGPT')
+    
+    if certified_index != -1 or chatgpt_index != -1:
+        # Cut off the text after 'ModMed Certified'
+        text = text[:certified_index]
+
+    tts = gTTS(text=text, lang='en', tld='co.uk')
+    audio_path = 'response.mp3'
+    tts.save(audio_path)
+    
+    return audio_path
+
+
+# Feedback radio button choices
+feedback_buttons = gr.Radio(
+    choices=["🏥 ModMed", "🤖 ChatGPT", "Clear"],
+    label="Which solution was better?",
+    default=None  # Set the default value to None
+)
+
+# Gradio Interface
+demo = gr.Interface(
+    fn=chatbot,
+    inputs=[
+        gr.Audio(source="microphone", type="filepath"),
+        gr.Audio(source="upload", type="filepath"),
+        feedback_buttons
+    ],
+    outputs=[
+        gr.Video(autoplay=True, label="ModMedicine"),
+        gr.outputs.HTML(label="ModMed Response"),
+        gr.outputs.HTML(label="ChatGpt Response"),
+        gr.Text(label="Trigger words"),
+        gr.Text(label="Feedback")
+    ],
+    examples=[
+        ["./dummy_audio1.mp3"],
+        ["./dummy_audio2.mp3"]
+    ],
+    title="First-Aid Bot",
+    description='<img src="https://drive.google.com/uc?id=1fWN0xn_KXLb0fCtTAyoxwacwzyH6w4am&export=download" alt="logo" style="display: block; margin: auto; width:125px;height:125px;">',
+    live=True
+)
+
+# Launch the Gradio interface
+demo.launch(server_name="0.0.0.0", server_port=7860)
+

index.md

@@ -0,0 +1,60 @@
+# First-Aid Bot
+
+## Overview
+
+**First-Aid Bot** is an award-winning senior project that earned the *People's Choice Award*. This collaborative endeavor was orchestrated by a talented team, each contributing their unique skills to craft a cutting-edge solution for medical assistance.
+
+![First-Aid Bot](https://cdn-uploads.huggingface.co/production/uploads/64c57ab6a3f7a8107dba1022/pfjSOmtlOBK0YMWUxXh2B.jpeg)
+
+## Team Members
+
+- ### Diego Gama (Team Leader, UI Developer, OpenAI Whisper, User Feedback)
+  - Led the project with a focus on the user interface.
+  - Implemented a sophisticated backend feedback counter for users' preferred models.
+  - Specialized in technologies like *OpenAI Whisper* and *Gradio*.
+
+- ### Jamar Andrade (OpenAI Whisper, OpenAI ChatGPT, Docker Spaces, Gradio)
+  - Worked on the integration of *OpenAI Whisper* and *OpenAI ChatGPT* for audio-to-text processing and prompt engineering.
+  - Utilized *Docker* for efficient deployment and integrated *Gradio* for a user-friendly interface.
+
+- ### Charles Bazile (Pinecone, ClinicalBERT)
+  - Worked on integrating *Pinecone* and *ClinicalBERT* into the application.
+  - Contributed to the advanced features that enhance the medical capabilities of First-Aid Bot.
+
+- ### Cesaire Civil (LangChain, ChromaDB)
+  - Specialized in *LangChain* and *ChromaDB*.
+  - Implemented the intelligent language processing and curated dataset retrieval functionalities.
+
+- ### Christopher Rodriguez (ChromaDB, Pinecone, Gradio)
+  - Focused on the integration of *ChromaDB* and *Pinecone*.
+  - Contributed to the implementation of *Gradio* for a seamless user experience.
+
+## Sponsored by Modern Medicine
+
+The success of **First-Aid Bot** was made possible through the generous sponsorship of *Modern Medicine*. Their support and collaboration enriched the project, providing valuable insights and access to a curated dataset of past doctor-client interactions, making the application more effective and reliable.
+
+## Technologies Used
+
+![Technologies Used](https://cdn-uploads.huggingface.co/production/uploads/64c57ab6a3f7a8107dba1022/pVyDcrBkRHiXvMWLQHzI_.png)
+
+## Hugging Face Deployment
+
+**First-Aid Bot** is hosted on *Hugging Face* using *DockerSpace*. To experience the application, simply follow the link below:
+
+[First-Aid Bot - Hugging Face Deployment](https://huggingface.co/spaces/Jamar561/FirstAid-Bot)
+
+## PowerPoint Presentation
+
+[Link to PowerPoint Presentation](https://docs.google.com/presentation/d/1wfDbsV_VQZneTKxGB-qSgcALTu0C4O0p/edit?usp=sharing&ouid=109114647024700962274&rtpof=true&sd=true)
+
+## Recognition
+
+The **First-Aid Bot** project received the *People's Choice Award*, a testament to the team's dedication and the impactful solution they crafted. This readme is not just a guide; it's an acknowledgment of the collective effort that went into making **First-Aid Bot** a success.
+
+## Getting Started
+
+To explore **First-Aid Bot**:
+
+1. [Access the deployed application](https://huggingface.co/spaces/Jamar561/FirstAid-Bot)
+
+Thank you for being part of the **First-Aid Bot** journey!

medical_data/dolphins_injury_report.txt

@@ -0,0 +1,24 @@
+Miami Dolphins cornerback Jalen Ramsey is expected to miss at least six to eight weeks due to a meniscus injury that will require surgery on his left knee, NFL Network Insiders Tom Pelissero and Mike Garafolo reported Thursday. Ramsey was injured in Miami's practice earlier in the day.
+
+Dolphins head coach Mike McDaniel on Friday confirmed that Ramsey injured his meniscus and will undergo knee surgery at 1 p.m. ET on Friday.
+
+"The length of this rehabilitation is kind of dictated on a couple of things that could occur in the surgery," McDaniel explained to reporters. "The exact timeline is a little to be determined. What I can tell you is I don't think the beginning of the regular season is really a part of the scenario. It's going to be into the season and how deep that is depends kind of on what happens today."
+
+NFL Network Insider Ian Rapoport previously reported on Thursday night it's likely Ramsey will require a full meniscus repair, which would put his return date all the way back to December. Ultimately, doctors will determine how severe the injury is, and therefore what course of action they must take to fix it. If the ligament can just be trimmed, Ramsey could be back as soon as six weeks, setting him up to return just around the Dolphins' season opener versus the Chargers on Sept. 10 -- though McDaniel expressed his doubt that Ramsey would be available Week 1 even under an optimistic timeline.
+
+If doctors determine they need to remove the meniscus, that would increase the cornerback's recovery timeline, Pelissero and Garafolo reported on Thursday.
+
+Ramsey released a statement on social media, writing that he'd "be back on that field stronger than ever... in due time" and that "I know my brothers gone hold it down until I'm back tho!"
+
+However, Ramsey followed soon after with another tweet that appeared to lean to a longer recovery time.
+
+
+The injury appeared to occur near the end of practice when Ramsey forced an incomplete pass and grabbed his knee after the play, Wolfe reported Thursday morning. Though Ramsey initially tried to stay on the field, he eventually exited to be looked at by trainers and later was carted off.
+
+This will mark Ramsey's second meniscus surgery, having previously undergone a procedure on his right knee in 2016 as a rookie. In that instance, Ramsey was able to return around six weeks post-op, and will be hoping for a similar outcome this time around.
+
+If Ramsey were to miss time in the regular season, the Dolphins would be playing without one of their most significant offseason additions, having traded with the Rams to acquire him in March. The six-time Pro Bowler was expected to become half of a dynamic duo alongside CB Xavien Howard, with the aim of bolstering a secondary that also includes Jevon Holland and Brandon Jones.
+
+In line to see time opposite Howard as Ramsey recovers are CB Kader Kohou, who started 13 games in his rookie season, and 2023 second-round pick Cam Smith out of South Carolina, with three preseason games available for both to work with the starters.
+
+"I feel good about the entire crew," McDaniel said on Friday. "We are dealing with some injuries now in that group. But I feel very, very good about the competition there, and the guys that are ready to go see some more opportunities. There's Pro Bowlers and hungry young guys and everything in between. So it'll be outstanding work for us moving forward."

medical_data/first-aid.txt

@@ -0,0 +1,44 @@
+To clean a wound, wash it with soap and water. If the wound is dirty, you can also use a mild antiseptic.
+
+To dress a wound, apply a bandage or gauze pad to the wound. You can also use antibiotic ointment to help prevent infection.
+
+To prevent infection, keep the wound clean and covered. You should also avoid touching the wound with dirty hands.
+
+To recognize the common cold, look for symptoms such as a runny nose, sore throat, and cough. To treat a cold, you can rest, drink plenty of fluids, and take over-the-counter medications.
+
+To recognize the flu, look for symptoms such as fever, body aches, and fatigue. To treat the flu, you can rest, drink plenty of fluids, and take over-the-counter medications or antiviral medications.
+
+To recognize allergies, look for symptoms such as sneezing, runny nose, and itchy eyes. To treat allergies, you can avoid the allergens that trigger your allergies, take over-the-counter medications, or get allergy shots.
+
+If you have a wound that is bleeding heavily, is deep, or is in a place that is difficult to clean, you should seek medical attention.
+
+For Cuts and Scrapes Wash your hands thoroughly. Clean the wound gently with mild soap and warm water. Apply an over-the-counter antibiotic ointment. Cover the wound with a clean bandage or sterile dressing.
+
+Burns For minor burns (first-degree), Run cool (not cold) water over the burn for about 10-20 minutes, Cover with a sterile non-stick dressing. For more severe burns (second or third-degree) Seek immediate medical attention.
+
+Sprains and Strains, Rest the injured area. Apply ice wrapped in a cloth for 15-20 minutes every 1-2 hours. Use compression bandages if necessary. Elevate the injured limb above heart level to reduce swelling.
+
+Nosebleeds, Tilt your head forward slightly (not backward) to prevent swallowing blood. Pinch your nostrils together and breathe through your mouth. Apply gentle pressure for 10-15 minutes. If bleeding persists, seek medical attention.
+
+Choking, If someone is choking and can't breathe or speak, perform the Heimlich maneuver. For infants, use back blows and chest thrusts. Seek immediate medical attention if the obstruction isn't cleared.
+
+Allergic Reactions, For mild allergic reactions (itchy skin, mild hives), Take an antihistamine if available and follow the label instructions. For severe allergic reactions (anaphylaxis), Use an epinephrine auto-injector if prescribed. Call 911 immediately.
+
+Insect Bites and Stings, Remove the stinger if present (for bee stings). Wash the area with soap and water. Apply a cold compress to reduce swelling and itching. Use over-the-counter antihistamines or pain relievers if needed.
+
+Heat Exhaustion/Heat Stroke,  Move to a cooler place and rest. Drink water and cool down with damp cloths or a cool bath. Heat stroke is a medical emergency; call 911 immediately.
+
+For diarrhea, drink plenty of fluids to prevent dehydration.
+For earache, apply a warm compress to the ear.
+For fever, take acetaminophen or ibuprofen to reduce the temperature.
+For a head injury, apply ice to the area and seek medical attention if necessary.
+For a high blood pressure reading, rest and avoid caffeine and alcohol.
+For a bee sting, remove the stinger and apply a cold compress to the area.
+For a bug bite, apply calamine lotion to the affected area.
+For a cold, rest, drink plenty of fluids, and gargle with salt water.
+For a concussion, rest and avoid strenuous activity.
+For a cough, drink plenty of fluids and suck on lozenges.
+For a dog bite, wash the wound with soap and water and seek medical attention.
+For a fever, dress lightly and sponge bathe with lukewarm water.
+For a headache, take acetaminophen or ibuprofen to relieve pain.
+For a heart attack, lie down and rest while waiting for medical help. call 911 immediately and chew an aspirin if available.

requirements.txt

@@ -0,0 +1,20 @@
+gradio==3.44.4
+langchain==0.0.300
+openai==0.27.8
+fastapi==0.99.1
+Flask==2.3.3
+Flask-Cors==4.0.0
+uvicorn==0.23.2
+python-dotenv==1.0.0
+Chroma==0.2.0
+chroma-hnswlib==0.7.3
+chromadb==0.4.12
+tiktoken==0.3.1
+transformers==4.31.0
+gtts==2.4.0
+bson>=0.5.10
+pymongo==4.6.0
+requests==2.31.0
+requests-oauthlib==1.3.1
+pinecone-client==2.2.4
+torch==2.1.1