Deploy FastAPI app

Dockerfile

@@ -0,0 +1,17 @@
+# Use Python base image
+FROM python:3.9-slim
+
+# Set the working directory
+WORKDIR /app
+
+# Copy project files to the container
+COPY . /app
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the default FastAPI port
+EXPOSE 8000
+
+# Command to run FastAPI with Uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

app/main.py

@@ -0,0 +1,90 @@
+from fastapi import FastAPI, Request, Form
+from fastapi.responses import RedirectResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+# from fastapi.middleware.cors import CORSMiddleware
+from helpmate_ai import initialize_conversation, retreive_results, rerank_with_cross_encoder, generate_response
+import re
+import google.generativeai as genai
+
+# Configure Gemini API
+gemini_api_key = open("gemini_api_key.txt", "r").read().strip()
+genai.configure(api_key=gemini_api_key)
+
+# Initialize FastAPI app
+app = FastAPI()
+
+# Set up templates
+templates = Jinja2Templates(directory="templates")
+
+# Serve static files (if needed)
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Enable CORS middleware if needed
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],  # Adjust origins as per requirements
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+def format_rag_response(response_text):
+    formatted_text = response_text.replace("\n", "<br>")
+    formatted_text = re.sub(r'(\*\*.*?\*\*)', r'<strong>\1</strong>', formatted_text).replace("**", "")
+    formatted_text = re.sub(r'(\d+\.\s)', r'<br><strong>\1</strong>', formatted_text)
+    formatted_text = re.sub(r'(\-\s)', r'<br>&bull; ', formatted_text)
+    formatted_text = re.sub(r'(Citations?:\s)', r'<br><em>\1</em>', formatted_text)
+    formatted_text = re.sub(r'\|\s*', r'</td><td>', formatted_text)
+    formatted_text = re.sub(r'\n\|\s*', r'<tr><td>', formatted_text)
+    return formatted_text
+
+conversation_bot = []
+conversation = initialize_conversation()
+
+# Initialize Gemini model
+model = genai.GenerativeModel("gemini-1.5-flash", system_instruction=conversation)
+
+def get_gemini_completions(conversation):
+    response = model.generate_content(conversation)
+    return response.text
+
+introduction = get_gemini_completions(conversation)
+conversation_bot.append({'bot': introduction})
+top_3_laptops = None
+
+@app.get("/")
+async def default_func(request: Request):
+    global conversation_bot
+    return templates.TemplateResponse("index_invite.html", {"request": request, "name_xyz": conversation_bot})
+
+@app.post("/end_conv")
+async def end_conv():
+    global conversation_bot, conversation, top_3_laptops
+    conversation_bot = []
+    conversation = initialize_conversation()
+    introduction = get_gemini_completions(conversation)
+    conversation_bot.append({'bot': introduction})
+    top_3_laptops = None
+    return RedirectResponse(url="/", status_code=303)
+
+@app.post("/invite")
+async def invite(user_input_message: str = Form(...)):
+    global conversation_bot, conversation, top_3_laptops
+    user_input = user_input_message
+    conversation_bot.append({'user': user_input})
+
+    results_df = retreive_results(user_input)
+    top_docs = rerank_with_cross_encoder(user_input, results_df)
+
+    # Generate response
+    messages = generate_response(user_input, top_docs)
+    response_assistant = get_gemini_completions(messages)
+
+    conversation_bot.append({'bot': format_rag_response(response_assistant)})
+    return RedirectResponse(url="/", status_code=303)
+
+# Run the application
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000, debug=True)

chroma/198995c5-3e47-440b-98d8-b095e7b992c3/data_level0.bin

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

chroma/198995c5-3e47-440b-98d8-b095e7b992c3/header.bin

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

chroma/198995c5-3e47-440b-98d8-b095e7b992c3/length.bin

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

chroma/chroma.sqlite3

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

chroma/ed2d8aa0-0cf3-4a31-b498-d3e7dcdc5566/data_level0.bin

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

chroma/ed2d8aa0-0cf3-4a31-b498-d3e7dcdc5566/header.bin

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

chroma/ed2d8aa0-0cf3-4a31-b498-d3e7dcdc5566/length.bin

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

chroma/f190ba25-fd88-4232-a7dc-2390c45704d4/data_level0.bin

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

chroma/f190ba25-fd88-4232-a7dc-2390c45704d4/header.bin

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

chroma/f190ba25-fd88-4232-a7dc-2390c45704d4/length.bin

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

chroma/f28c5b78-1366-45d0-b9f9-10f0ba9054ed/data_level0.bin

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

chroma/f28c5b78-1366-45d0-b9f9-10f0ba9054ed/header.bin

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

chroma/f28c5b78-1366-45d0-b9f9-10f0ba9054ed/length.bin

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

chroma/fc83983d-80db-49a4-a6fb-42834cc83377/data_level0.bin

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

chroma/fc83983d-80db-49a4-a6fb-42834cc83377/header.bin

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

chroma/fc83983d-80db-49a4-a6fb-42834cc83377/length.bin

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

chroma/fd3b321e-3bab-4583-88b0-405d918cd938/data_level0.bin

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

chroma/fd3b321e-3bab-4583-88b0-405d918cd938/header.bin

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

chroma/fd3b321e-3bab-4583-88b0-405d918cd938/length.bin

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

chroma/fd9978b6-a866-4bec-9cea-1215ebeb34e9/data_level0.bin

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

chroma/fd9978b6-a866-4bec-9cea-1215ebeb34e9/header.bin

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

chroma/fd9978b6-a866-4bec-9cea-1215ebeb34e9/length.bin

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

chroma/ff952c54-2ce3-4bd1-b8d0-3430b4745e3e/data_level0.bin

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

chroma/ff952c54-2ce3-4bd1-b8d0-3430b4745e3e/header.bin

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

chroma/ff952c54-2ce3-4bd1-b8d0-3430b4745e3e/length.bin

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

helpmate_ai.py

@@ -0,0 +1,860 @@
+# -*- coding: utf-8 -*-
+# Install all the required libraries
+
+# !pip install -U -q pdfplumber tiktoken openai chromaDB sentence-transformers
+
+# Import all the required Libraries
+
+import pdfplumber
+from pathlib import Path
+import pandas as pd
+from operator import itemgetter
+import json
+import tiktoken
+# import openai
+import chromadb
+
+# openai.api_key = open("api_key.txt", "r").read().strip()
+
+def initialize_conversation():
+    """
+    Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+    """
+    conversation = [
+            f"""
+            You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents.
+            The document name is 'Group Life Insurance Policy' and it contais information about 3 different insurance policies 'Member Life Insurance', 'Member Accidental Death and Dismemberment Insurance' and 'Dependent Life Insurance'.
+            Your task is to extract and present relevant information from the policy documents to answer the user’s query. The document excerpts are provided in the dataframe, with the actual policy text in the 'documents' column and metadata (page numbers) in the 'metadata' column.
+
+            <EXAMPLE>
+            INPUT: "What are the premium rates for different types of insurance under this policy?"
+
+            OUTPUT:
+            The premium rate(s) for each Member insured for Life Insurance will be:
+
+            Premium Rates:
+            1. Member Life Insurance: $0.210 for each $1,000 of insurance in force.
+            2. Member Accidental Death and Dismemberment Insurance: $0.025 for each $1,000 of Member Life Insurance in force.
+            3. Dependent Life Insurance: $1.46 for each Member insured for Dependent Life Insurance.
+
+            Multiple Policy Discount: The Policyholder may be eligible for a multiple policy discount if they have at least two other eligible group insurance policies underwritten by The Principal.
+
+            Citations: Policy Name: Group Life Insurance Policy, Page Number: 20.
+            </EXAMPLE>
+
+            <EXAMPLE>
+            INPUT: "What are the Contributions from Members?"
+
+            OUTPUT:
+            Members are not required to contribute a part of the premium for their Member insurance under this Group Policy.
+            Members are required to contribute a part of the premium for their Dependent's insurance under this Group Policy.
+
+            Citations: Policy Name: Group Life Insurance Policy, Page Number: 20.
+            </EXAMPLE>
+
+            Guidelines:
+            1. Extract information that directly answers the user's query from the document excerpts.
+            3. Provide the final response as a well-formatted and easily readable text along with the citation.
+            4. Provide your complete response using the relevant parts in the documents.
+            5. The generated response should answer the query directly addressing the user and avoiding additional information.
+            6. If the provided excerpts do not fully answer the query, provide partial information and suggest which sections of the policy document the user should review for further details.
+            7. If no relevant information is found in the provided excerpts, respond with 'No relevant information found in the provided excerpts.'
+            
+            # Start with a short welcome message with smiley only in the begining of the chat session and not in every response.
+            """
+    ] 
+                
+    # conversation = [{"role": "user", "parts": system_message}] 
+    # conversation = [{"role": "system", "content": system_message}]
+
+    return conversation
+
+"""#### Read, Process, and Chunk the PDF File
+
+We will be using **pdfplumber** library to read and process the PDF files.
+"""
+
+# Define the path of the PDF
+pdf_path = 'Principal-Sample-Life-Insurance-Policy.pdf'
+
+"""Reading PDF file and exploring it for delimeters to decide chunking stategy
+
+
+"""
+
+# Open the PDF file
+# with pdfplumber.open(pdf_path) as pdf:
+
+#     # Get one of the pages from the PDF and examine it
+#     single_page = pdf.pages[0]
+
+#     # Extract text from the first page
+#     text = single_page.extract_text()
+
+#     # Print the extracted text
+
+#     visible_text = text.replace("\n", "<NEWLINE>\n").replace("\t", "[TAB]").replace("  ", "[SPACE]")
+#     print(visible_text)
+    # print(text)
+
+"""*Looking at the the file we will go fixed-size chunking strategy either page or certain token size. We will experiment with various token-size for optimal output.*
+
+#### Function to perform Page-Based Chunking
+"""
+
+# Function to extract text page-wise from a PDF file.
+def extract_pages_from_pdf(pdf_path):
+    # p = 0
+    page_cunks = []
+
+    # with pdfplumber.open(pdf_path) as pdf:
+    pdf = pdfplumber.open(pdf_path);
+    for page_no, page in enumerate(pdf.pages):
+        # page_no = f"Page {p+1}"
+        text = page.extract_text()
+
+        page_cunks.append([page_no + 1, text])
+        # p +=1
+
+    return page_cunks
+page_cunks = extract_pages_from_pdf(pdf_path)
+
+# for page_chunk in page_cunks[0:5]:
+#   print(page_chunk)
+
+"""#### Functions to perform fixed size chunking using token-size
+
+We will be using OpenAI 'gpt-3.5-turbo' model for generating answer so we choose size of chunks such that it does not exceed token limit of the model which is 4096(input and output)
+"""
+
+# Load the tokenizer
+tokenizer = tiktoken.get_encoding("cl100k_base")
+# Define the token limit for each chunk
+TOKEN_SIZE = 512  # Adjust for optimal output
+
+def chunk_text_by_token_size(text, TOKEN_SIZE):
+    # Tokenize the text
+    tokens = tokenizer.encode(text)
+
+    # Chunk the tokens into fixed-size chunks
+    chunks = [tokens[i:i + TOKEN_SIZE] for i in range(0, len(tokens), TOKEN_SIZE)]
+
+    # Convert the chunks back into text
+    text_chunks = [tokenizer.decode(chunk) for chunk in chunks]
+
+    return text_chunks
+
+def fixed_size_chunking_of_pdf(pdf_path):
+    # Extract text from a PDF
+    with pdfplumber.open(pdf_path) as pdf:
+        # Initialize a list to store chunks
+        all_chunks = []
+
+        # Iterate over all the pages
+        for page_no, page in enumerate(pdf.pages):
+
+            # Extract text from the page
+            text = page.extract_text()
+
+            # Chunk the text based on token limit
+            page_chunks = chunk_text_by_token_size(text, TOKEN_SIZE)
+
+            for text_chunk in page_chunks:
+              all_chunks.append([f"{page_no + 1}", text_chunk])
+
+    return all_chunks
+
+# Append the chunks to the list
+all_chunks = fixed_size_chunking_of_pdf(pdf_path)
+
+# Example: Print the first chunk
+# for chunk in all_chunks[0:5]:
+#     print(chunk)
+
+"""We will store the chunks in a dataframe for further processng.
+
+chunks smaller than length 10 might be some empty pages or very few words so will be dropped.
+
+Depending on the chunking srategy relevant functions are called.
+"""
+
+# functions for storing chunks in data frame for further processing
+def store_docs_to_df(chunks):
+    # Initialize a list to store chunks
+    data = []
+    # Convert the extracted list to a DF, and add a column to store document names
+    extracted_text_df = pd.DataFrame(chunks, columns=['Page No.', 'Text'])
+    # Append the extracted text and Page number to the list
+    data.append(extracted_text_df)
+
+    # Concatenate all the DFs in the list 'data' together
+    insurance_pdf_data = pd.concat(data, ignore_index=True)
+    # insurance_pdfs_data.head(20)
+
+    # Let's also check the length of all the texts as there might be some empty pages or with very few words that we can drop
+
+    insurance_pdf_data['Text_Length'] = insurance_pdf_data['Text'].apply(lambda x: len(x.split(' ')))
+    insurance_pdf_data['Text_Length']
+
+    # Retain only the rows with a text length of at least 10
+
+    insurance_pdf_data = insurance_pdf_data.loc[insurance_pdf_data['Text_Length'] >= 10]
+    # insurance_pdfs_data
+
+    # Store the metadata for each page in a separate column
+    # insurance_pdfs_data['Metadata'] = insurance_pdfs_data.apply(lambda x: {'Page No.': x['Page No.'], 'Chunk No': x['Chunk No']}, axis=1)
+    insurance_pdf_data['Metadata'] = insurance_pdf_data.apply(lambda x: {'Page No.': x['Page No.']}, axis=1)
+    # insurance_pdfs_data
+
+    return insurance_pdf_data
+
+chunks_df = store_docs_to_df(page_cunks) # page based chunking
+# chunks_df = store_docs_to_df(all_chunks) # chunking based on size=token-size
+
+# chunks_df.tail(5)
+
+"""## Generate and Store Embeddings
+
+In this section, we will embed the chunks and store them in a ChromaDB collection.
+"""
+
+# Define the path where chroma collections will be stored
+chroma_data_path = '/content/drive/MyDrive/HelpMate_AI_Codes/ChromaDB_Data'
+
+# Import the OpenAI Embedding Function into chroma
+# from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+# embedding_function = OpenAIEmbeddingFunction(
+#     api_key=openai.api_key,
+#     model_name="text-embedding-ada-002"
+# )
+
+# Import the SentenceTransformer Embedding Function into chroma
+from chromadb.utils import embedding_functions
+# embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="paraphrase-mpnet-base-v2")
+# embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="multi-qa-MiniLM-L6-cos-v1")
+embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
+
+# Call PersistentClient() so the collections including cache can be stored in a permanent storage
+client = chromadb.PersistentClient()
+
+"""
+
+We will also implement a data/collection cache to improve the performance of the overall search system."""
+
+# Set up the embedding function
+
+def generate_embeddings(chunks_df, embedding_function):
+
+    all_collections = client.list_collections()
+    collection_exists = any(col.name == 'RAG_on_Insurance' for col in all_collections)
+
+    if collection_exists:
+      client.delete_collection(name='RAG_on_Insurance')
+
+    # Initialise a collection in chroma and pass the embedding_function to it so that it uses embedding model to embed the documents
+    insurance_collection = client.get_or_create_collection(name='RAG_on_Insurance', embedding_function=embedding_function)
+
+    # Convert the page text and metadata from your dataframe to lists to be able to pass it to chroma
+    documents_list = chunks_df["Text"].tolist()
+    metadata_list = chunks_df['Metadata'].tolist()
+
+    # Add the documents and metadata to the collection alongwith generic integer IDs. You can also feed the metadata information as IDs by combining the policy name and page no.
+
+    insurance_collection.add(
+        documents= documents_list,
+        ids = [str(i) for i in range(0, len(documents_list))],
+        metadatas = metadata_list
+    )
+
+    collection_exists = any(col.name == 'Insurance_Cache' for col in all_collections)
+
+    if collection_exists:
+      client.delete_collection(name='Insurance_Cache')
+
+    cache_collection = client.get_or_create_collection(name='Insurance_Cache', embedding_function=embedding_function)
+
+    # print(client.list_collections())
+
+    # print(cache_collection.peek())
+
+    # cache_results = cache_collection.query(
+    #     query_texts=query,
+    #     n_results=1
+    # )
+
+    # print(cache_results)
+
+    return insurance_collection, cache_collection
+
+insurance_collection, cache_collection = generate_embeddings(chunks_df, embedding_function)
+# insurance_collection.peek(5)
+
+# Let's take a look at the first few entries in the collection
+# sample = insurance_collection.peek(5)
+# sample
+# print(insurance_collection.get(
+#     ids = ['4','5','6'],
+#     include = ['documents', 'metadatas']
+# ))
+
+"""##<font color = yellow> Search Layer
+
+### Semantic Search with Cache
+
+We will perform a semantic search of a query in the collections embeddings to get several top semantically similar results based on the *distance* parameter.
+"""
+
+# test query
+# query = "What are the premium rates for different types of insurance under this policy?"
+# query = "what are the benefits payable for different types of insurance under this policy?"
+# query = "What are the Contributions from Members??"
+
+"""#### Document retreival"""
+
+# Implementing Cache in Semantic Search
+
+def retreive_results(query):
+    # Set a threshold for cache search
+    threshold = 0.2
+
+    ids = []
+    documents = []
+    distances = []
+    metadatas = []
+
+    results_df = pd.DataFrame()
+
+    # Searh the Cache collection first
+    # Query the collection against the user query and return the top 20 results
+
+    cache_results = cache_collection.query(
+        query_texts=query,
+        n_results=1
+    )
+
+    # print(cache_results)
+    # print(f"cache_results top distance: {cache_results['distances'][0][0]}")
+
+    # If the distance is greater than the threshold, then return the results from the main collection.
+    if cache_results['distances'][0] == [] or cache_results['distances'][0][0] > threshold:
+          # Query the collection against the user query and return the top 10 results
+          results = insurance_collection.query(
+          query_texts=query,
+          n_results=10
+          )
+
+          # Store the query in cache_collection as document w.r.t to ChromaDB so that it can be embedded and searched against later
+          # Store retrieved text, ids, distances and metadatas in cache_collection as metadatas, so that they can be fetched easily if a query indeed matches to a query in cache
+          Keys = []
+          Values = []
+
+          for key, val in results.items():
+            if val is None:
+              continue
+            if key in ['ids', 'metadatas', 'documents', 'distances']:
+              for i in range(10):
+                Keys.append(str(key)+str(i))
+                Values.append(str(val[0][i]))
+                # print(key, i)
+
+          cache_collection.add(
+              documents= [query],
+              ids = [query],  # Or if you want to assign integers as IDs 0,1,2,.., then you can use "len(cache_results['documents'])" as will return the no. of queries currently in the cache and assign the next digit to the new query."
+              metadatas = dict(zip(Keys, Values))
+          )
+
+          # print("Not found in cache. Found in main collection.")
+
+          result_dict = {'Metadatas': results['metadatas'][0], 'Documents': results['documents'][0], 'Distances': results['distances'][0], "IDs":results["ids"][0]}
+          results_df = pd.DataFrame.from_dict(result_dict)
+
+    # If the distance is, however, less than the threshold, you can return the results from cache
+
+    elif cache_results['distances'][0][0] <= threshold:
+          cache_result_dict = cache_results['metadatas'][0][0]
+
+          # Loop through each inner list and then through the dictionary
+          for key, value in cache_result_dict.items():
+              if 'ids' in key:
+                  ids.append(value)
+              elif 'documents' in key:
+                  documents.append(value)
+              elif 'distances' in key:
+                  distances.append(value)
+              elif 'metadatas' in key:
+                  metadatas.append(value)
+
+          print("Found in cache!")
+
+          # Create a DataFrame
+          results_df = pd.DataFrame({
+            'IDs': ids,
+            'Documents': documents,
+            'Distances': distances,
+            'Metadatas': metadatas
+          })
+
+    # print(results_df)
+
+    return results_df
+
+# results_df = retreive_results(query, insurance_collection, cache_collection)
+# results_df.head(5)
+
+"""#### Re-Ranking with a Cross Encoder
+
+We will perform Re-ranking of the search results using cross-encoder to move more relevant chunks at the top.
+"""
+
+# Import the CrossEncoder library from sentence_transformers
+from sentence_transformers import CrossEncoder, util
+# Initialise the cross encoder model
+# cross_encoder = CrossEncoder('cross-encoder/ms-marco-TinyBERT-L-6')
+# cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
+cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+
+#function to re-rank results using cross-encoder
+def rerank_with_cross_encoder(query, results_df, top_k=3):
+
+    # Input (query, response) pairs for each of the top 10 responses received from the semantic search to the cross encoder
+    # Generate the cross_encoder scores for these pairs
+
+    cross_inputs = [[query, response] for response in results_df['Documents']]
+    cross_rerank_scores = cross_encoder.predict(cross_inputs)
+    # print(cross_rerank_scores)
+
+    # Store the rerank_scores in results_df
+    results_df['Reranked_scores'] = cross_rerank_scores
+    # print(results_df)
+
+    # Return the top_kresults from semantic search
+    top_semantic = results_df.sort_values(by='Distances')
+    # print(top_semantic[:top_k])
+
+    # Return the top_k results after reranking
+    top_ranks_df = results_df.sort_values(by='Reranked_scores', ascending=False)
+    # print(top_ranks[:top_k])
+
+    top_docs = top_ranks_df[["Documents", "Metadatas"]][:top_k]
+    # top_ranks = top_ranks[:][:top_k]
+    print(top_docs)
+
+    return top_docs #, top_ranks_df
+
+# top_docs = rerank_with_cross_encoder(results_df)
+# top_docs
+
+"""##<font color = yellow> Generative Layer
+
+### Retrieval Augmented Generation(RAG)
+
+We will now use OpenAI *gpt-3.5-turbo* along with the user query and prompt with top ranked docs, to generate a direct answer to the query along with citations.
+"""
+
+# # Define the function to generate the response. Provide a comprehensive prompt that passes the user query and the top 3 results to the model
+
+# def create_prompt(query, top_docs):
+#     """
+#     Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+#     """
+#     prompt = [
+#                 {"role": "system", "content":  "You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents."},
+#                 {"role": "user", "content": f"""You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents.
+#                                                 You have a question asked by the user in '{query}' and you have some search results from a corpus of insurance documents in the dataframe '{top_docs}'.
+#                                                 These search results are essentially one paragraph of an insurance document that may be relevant to the user query.
+
+#                                                 The column 'documents' inside this dataframe contains the actual text from the policy document and the column 'metadata' contains the source page.
+
+#                                                 The policy document describes about 3 different policies 'Member Life Insurance', 'Member Accidental Death and Dismemberment Insurance' and 'Dependent Life Insurance'
+
+#                                                 Use the documents in '{top_docs}' to answer the query '{query}'.
+
+#                                                 Follow the guidelines below when performing the task:
+#                                                 1. Try to provide relevant/accurate numbers if available.
+#                                                 2. You don’t have to necessarily use all the information in the dataframe. Only choose information that is relevant.
+#                                                 3. If you can't provide the complete answer, please also provide any information that will help the user to search specific sections in the relevant cited documents.
+#                                                 4. You are a customer facing assistant, so do not provide any information on internal workings, just answer the query directly.
+#                                                 5. If you think that the query is not relevant to the document, reply that the query is irrelevant.
+#                                                 6. Provide the final response as a well-formatted and easily readable text along with the citation.
+#                                                 7. Provide your complete response using the relevant parts in the documents.
+#                                                 8. The generated response should answer the query directly addressing the user and avoiding additional information.
+#                                                 9. Provide the final response as a well-formatted and easily readable text.
+
+#                                                 """},
+#               ]
+
+#     return prompt
+
+# # Define the function to generate the response. Provide a comprehensive prompt that passes the user query and the top 3 results to the model
+
+# def create_prompt(query, top_docs):
+#     """
+#     Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+#     """
+#     prompt = [
+#                 {"role": "system", "content":  "You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents."},
+#                 {"role": "user", "content": f"""You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents.
+#                                                 You have a question asked by the user in '{query}' and you have some search results from a corpus of insurance documents in the dataframe '{top_docs}'. These search results are essentially one paragraph of an insurance document that may be relevant to the user query.
+
+#                                                 The column 'documents' inside this dataframe contains the actual text from the policy document and the column 'metadata' contains the source page.
+
+#                                                 The policy document describes about 3 different policies 'Member Life Insurance', 'Member Accidental Death and Dismemberment Insurance' and 'Dependent Life Insurance'
+
+#                                                 Use the documents in '{top_docs}' to answer the query '{query}'.
+
+#                                                 Follow the guidelines below when performing the task.
+#                                                 1. Try to provide relevant/accurate numbers if available.
+#                                                 2. You don’t have to necessarily use all the information in the dataframe. Only choose information that is relevant.
+#                                                 4. If you can't provide the complete answer, please also provide any information that will help the user to search specific sections in the relevant cited documents.
+#                                                 5. You are a customer facing assistant, so do not provide any information on internal workings, just answer the query directly.
+#                                                 6. If you think that the query is not relevant to the document, reply that the query is irrelevant.
+#                                                 7. Provide the final response as a well-formatted and easily readable text along with the citation.
+#                                                 8. Provide your complete response using the relevant parts in the documents.
+
+#                                                 The generated response should answer the query directly addressing the user and avoiding additional information. Provide the final response as a well-formatted and easily readable text.
+#                                                 **Example 1:**
+#                                                 **Query**: "What are the benefits of the whole life insurance policy?"
+#                                                 **Search Results**: Dataframe contains an excerpt from a whole life insurance policy document: "The policy provides lifelong coverage, a guaranteed death benefit, and a cash value component that grows over time."
+#                                                 **Response**: "The whole life insurance policy offers lifelong coverage with a guaranteed death benefit. Additionally, it accumulates cash value over time, which can be accessed or borrowed against by the policyholder."
+#                                                 **Citations**: Policy Name: Lifetime Protection Plan, Page: 7
+
+#                                                 **Example 2:**
+#                                                 **Query**: "What is the death benefit for a final expense life insurance policy?"
+#                                                 **Search Results**: Dataframe contains a document with the following excerpt: "The final expense policy provides a death benefit of up to $10,000, intended to cover funeral costs and other end-of-life expenses."
+#                                                 **Response**: "The final expense life insurance policy provides a death benefit of up to $10,000, which is typically used to cover funeral costs and other end-of-life expenses."
+#                                                 **Citations**: Policy Name: Final Expense Protection, Page: 3
+
+#                                                 """},
+#               ]
+
+#     return prompt
+
+# # Define the function to generate the response. Provide a comprehensive prompt that passes the user query and the top 3 results to the model
+
+# def create_prompt(query, top_docs):
+
+#     """
+#     Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+#     """
+#     prompt = [
+#                 {
+#                   "role": "system",
+#                   "content": "You are a helpful assistant that extracts relevant information from insurance policy documents to answer user queries accurately and concisely."
+#                 },
+#                 {
+#                   "role": "user",
+#                   "content": f"""
+#                   You are given a user query and a set of relevant insurance policy document excerpts retrieved by a Retrieval-Augmented Generation (RAG) system.
+
+#                   Your task is to extract and present relevant information from the policy documents to answer the user’s query. The document excerpts are provided in the dataframe '{top_docs}', with the actual policy text in the 'documents' column and metadata (page numbers) in the 'metadata' column.
+
+#                   The document name is 'Group Life Insurance Policy' and it contais information about 3 different insurance policies 'Member Life Insurance', 'Member Accidental Death and Dismemberment Insurance' and 'Dependent Life Insurance'.
+
+#                   Guidelines:
+#                   1. Extract information that directly answers the user's query from the document excerpts.
+#                   2. Organize the response using clear headings, bullet points, or tables where applicable.
+#                   3. Cite the relevant policy name(s) and page number(s) using the metadata from the dataframe.
+#                   4. If the provided excerpts do not fully answer the query, provide all available information and suggest which sections of the policy document the user should review for further details.
+#                   5. If no relevant information is found in the provided excerpts, respond with 'No relevant information found in the provided excerpts.'
+
+#                   ### Example Query:
+#                   **User Query**: "What are the premium rates for different types of insurance under this policy?"
+
+#                   **Extracted Information**:
+#                   **Article 2 - Premium Rates**:
+#                   1. **Member Life Insurance**: $0.210 for each $1,000 of insurance in force.
+#                   2. **Member Accidental Death and Dismemberment Insurance**: $0.025 for each $1,000 of Member Life Insurance in force.
+#                   3. **Dependent Life Insurance**: $1.46 for each Member insured for Dependent Life Insurance.
+
+#                   **Multiple Policy Discount**: The Policyholder may be eligible for a multiple policy discount if they have at least two other eligible group insurance policies underwritten by The Principal.
+
+#                   **Citations**: Policy Name: Group Life Insurance Policy, Page Number: 12.
+
+#                   ### Your Task:
+#                   The user query is: '{query}'
+#                   """
+#                 }
+#               ]
+#     return prompt
+
+# # function to create prompt having the top ranked docs and query.
+
+# def create_prompt(query, top_docs):
+
+#     """
+#     Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+#     """
+#     prompt = [
+#                 {
+#                   "role": "system",
+#                   "content": "You are a helpful assistant that extracts relevant information from insurance policy documents to answer user queries accurately and concisely."
+#                 },
+#                 {
+#                   "role": "user",
+#                   "content": f"""
+#                   You are given a user query and a set of relevant insurance policy document excerpts retrieved by a Retrieval-Augmented Generation (RAG) system.
+
+#                   Your task is to extract and present relevant information from the policy documents to answer the user’s query. The document excerpts are provided in the dataframe '{top_docs}', with the actual policy text in the 'documents' column and metadata (page numbers) in the 'metadata' column.
+
+#                   The document name is 'Group Life Insurance Policy' and it contais information about 3 different insurance policies 'Member Life Insurance', 'Member Accidental Death and Dismemberment Insurance' and 'Dependent Life Insurance'.
+
+#                   Guidelines:
+#                   1. Extract information that directly answers the user's query from the document excerpts.
+#                   2. Organize the response using clear headings, bullet points, or tables where applicable.
+#                   3. If the text includes tables with relevant information, reformat them into a clear, readable structure.
+#                   4. Cite the relevant policy name(s) and page number(s) using the metadata from the dataframe.
+#                   5. If the provided excerpts do not fully answer the query, provide partial information and suggest which sections of the policy document the user should review for further details.
+#                   6. If no relevant information is found in the provided excerpts, respond with 'No relevant information found in the provided excerpts.'
+
+#                   ### Example Query:
+#                   **User Query**: "What are the premium rates for different types of insurance under this policy?"
+
+#                   **Premium Rates**:
+#                   1. **Member Life Insurance**: $0.210 for each $1,000 of insurance in force.
+#                   2. **Member Accidental Death and Dismemberment Insurance**: $0.025 for each $1,000 of Member Life Insurance in force.
+#                   3. **Dependent Life Insurance**: $1.46 for each Member insured for Dependent Life Insurance.
+
+#                   **Multiple Policy Discount**: The Policyholder may be eligible for a multiple policy discount if they have at least two other eligible group insurance policies underwritten by The Principal.
+
+#                   **Citations**: Policy Name: Group Life Insurance Policy, Page Number: 12.
+
+#                   ### Your Task:
+#                   The user query is: '{query}'
+#                   """
+#                 }
+#               ]
+#     return prompt
+
+# prompt = create_prompt(query, top_docs)
+
+# # function to generate the response.
+
+# def generate_response(query, top_docs):
+#     """
+#     Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+#     """
+#     messages = [
+#                 {"role": "system", "content":  "You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents."},
+#                 {"role": "user", "content": f"""You are a helpful assistant in the insurance domain who can effectively answer user queries about insurance policies and documents.
+#                                                 You have a question asked by the user in '{query}' and you have some search results from a corpus of insurance documents in the dataframe '{top_docs}'. These search results are essentially one page of an insurance document that may be relevant to the user query.
+
+#                                                 The column 'documents' inside this dataframe contains the actual text from the policy document and the column 'metadata' contains the policy name and source page. The text inside the document may also contain tables in the format of a list of lists where each of the nested lists indicates a row.
+
+#                                                 Use the documents in '{top_docs}' to answer the query '{query}'. Frame an informative answer and also, use the dataframe to return the relevant policy names and page numbers as citations.
+
+#                                                 Follow the guidelines below when performing the task.
+#                                                 1. Try to provide relevant/accurate numbers if available.
+#                                                 2. You don’t have to necessarily use all the information in the dataframe. Only choose information that is relevant.
+#                                                 3. If the document text has tables with relevant information, please reformat the table and return the final information in a tabular in format.
+#                                                 3. Use the Metadatas columns in the dataframe to retrieve and cite the policy name(s) and page numbers(s) as citation.
+#                                                 4. If you can't provide the complete answer, please also provide any information that will help the user to search specific sections in the relevant cited documents.
+#                                                 5. You are a customer facing assistant, so do not provide any information on internal workings, just answer the query directly.
+
+#                                                 The generated response should answer the query directly addressing the user and avoiding additional information. If you think that the query is not relevant to the document, reply that the query is irrelevant. Provide the final response as a well-formatted and easily readable text along with the citation. Provide your complete response first with all information, and then provide the citations.
+#                                                 """},
+#               ]
+
+#     response = openai.chat.completions.create(
+#         model="gpt-3.5-turbo",
+#         messages=messages
+#     )
+
+#     return response.choices[0].message.content.split('\n')
+
+# response = generate_response(query, top_docs)
+# print(query + '\n')
+# print("\n".join(response))
+
+# function to generate the response.
+
+def generate_response(query, top_docs):
+    """
+    Generate a response using GPT-3.5's ChatCompletion based on the user query and retrieved information.
+    """
+    messages = f"""
+                Remember your system message and that you are a helpful assistant that extracts relevant information from insurance policy documents to answer user queries accurately and concisely.
+                Your task is to extract and present relevant information from the policy documents to answer the user’s query.
+                The document excerpts are provided in the dataframe '{top_docs}', with the actual policy text in the 'documents' column and metadata (page numbers) in the 'metadata' column.
+                The user input is: '{query}'
+                """
+
+    # response = openai.chat.completions.create (
+    #     model="gpt
+                  ### Your Task:-3.5-turbo",
+    #     messages=messages
+    # )
+    conversation = [{"role": "user", "parts": messages}] 
+
+    return conversation #response.choices[0].message.content.split('\n')
+
+# response = generate_response(query, top_docs)
+# print(query + '\n')
+# print("\n".join(response))
+
+"""## <font color = yellow> Query Search
+
+### <font color = yellow> Query #1
+"""
+
+# query1 = "what happens if failed to Pay Premium?"
+
+# results_df = retreive_results(query1, insurance_collection, cache_collection)
+# top_docs = rerank_with_cross_encoder(results_df)
+# top_docs
+
+# #generate response
+# response = generate_response(query1, top_docs)
+
+# print("\n".join(response))
+
+# """### <font color = yellow> Query #2"""
+
+# query2 = "what are the eligibility requirements for different types of insurance under this policy?"
+
+# results_df = retreive_results(query2, insurance_collection, cache_collection)
+# top_docs = rerank_with_cross_encoder(results_df)
+# top_docs
+
+# #generate response
+# response = generate_response(query2, top_docs)
+# print("\n".join(response))
+
+# """### <font color = yellow> Query #3"""
+
+# query3 = "What are the Termination Rights of the Policyholder?"
+
+# results_df = retreive_results(query3, insurance_collection, cache_collection)
+# top_docs = rerank_with_cross_encoder(results_df)
+# top_docs
+
+# #generate response
+# response = generate_response(query3, top_docs)
+# print("\n".join(response))
+
+# def run_pipeline(chunk_strategy,
+#                  embedding_function,
+#                  chroma_data_path,
+#                  query,
+#                  cross_encoder,
+#                  top_k,
+#                  rag_model,
+#                  prompt_style="default"):
+
+#     # Embedding layer
+#     # Preprocess documents
+
+#     # Extract text
+#     # Split into chunks
+#     if chunk_strategy == "page":
+#       docs = extract_pages_from_pdf(pdf_path)
+#     elif chunk_strategy == "fixed_size":
+#       docs = fixed_size_chunking_of_pdf(pdf_path)
+
+#     docs_df = store_docs_to_df(docs)
+
+#     # Generate embeddings and store in chromadb collection and cache
+#     insurance_collection, cache_collection = generate_embeddings(docs_df, embedding_function)
+
+#     # Retrieve documents relevant to query from collections and store in cache
+#     results_df = retreive_results(query, insurance_collection, cache_collection)
+
+#     # Re-rank with Cross Encoder
+#     top_re_ranks, top_df = rerank_with_cross_encoder(results_df, top_k)
+
+#     # Create prompt
+#     prompt = create_prompt(query, top_re_ranks)
+
+#     # Generate response
+#     response = generate_response(prompt, rag_model)
+
+#     return top_df, response
+
+# # select chunking strategy
+
+# # chunk_strategy = "page"
+# chunk_strategy = "fixed_size"
+# # Load the tokenizer
+# tokenizer = tiktoken.get_encoding("cl100k_base")
+# # Define the token limit for each chunk
+# TOKEN_SIZE = 500  # Adjust this based on your needs
+
+# # Import the OpenAI Embedding Function into chroma
+# from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction
+
+# # select the model and initialise the embedding function
+# # model = "text-embedding-ada-002"
+# # embedding_function = OpenAIEmbeddingFunction(api_key=openai.api_key, model_name=model)
+
+# from chromadb.utils import embedding_functions
+# embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="paraphrase-mpnet-base-v2")
+# # embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="multi-qa-MiniLM-L6-cos-v1")
+# # embedding_function = embedding_functions.SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")
+
+# # Import the CrossEncoder library from sentence_transformers
+# from sentence_transformers import CrossEncoder, util
+# # Initialise the cross encoder model
+# cross_encoder = CrossEncoder('cross-encoder/ms-marco-TinyBERT-L-6')
+# # cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-12-v2')
+# # cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')
+
+# # test query
+# # query = "what are the eligibility requirements?"
+# # query = "what are the eligibility requirements for different types of insurance under this policy?"
+
+# # query = "what are the benefits payable?"
+# # query = "what are the benefits payable for different types of insurance under this policy?"
+# # query = "What are the benefits payable of Member Accidental Death and Dismemberment Insurance?"
+# # query = "What are the benefits of Member Life Insurance?"
+
+# # query = "How much is the premium amount?"
+# # query = "How much is the premium amount for different types of insurance under this policy?"
+
+# # query = "How much is the premium rate?"
+# # query = "What are the premium rates for different types of insurance under this policy?"
+# # query = "What are the premium rates?"
+
+# # print(query)
+
+# # how much top query results to consider for generating response
+# top_k = 5
+
+# # select RAG model
+# rag_model = "gpt-3.5-turbo"
+
+# top_df, response = run_pipeline(chunk_strategy,
+#                         embedding_function,
+#                         chroma_data_path,
+#                         query,
+#                         cross_encoder,
+#                         top_k,
+#                         rag_model)
+# # results_df = run_pipeline(chunk_strategy,
+# #                         embedding_function,
+# #                         chroma_data_path,
+# #                         query,
+# #                         cross_encoder,
+# #                         top_k,
+# #                         rag_model)
+
+# # top_re_ranks = run_pipeline(chunk_strategy,
+# #                         embedding_function,
+# #                         chroma_data_path,
+# #                         query,
+# #                         cross_encoder,
+# #                         top_k,
+# #                         rag_model)
+
+# print("\n".join(response))
+# # print(prompt)
+# # top_re_ranks
+# # docs_df.head(100)
+# # top_semantic_search
+# top_df
+# # results_df
+
+
+
+
+
+
+

requirements.txt

@@ -0,0 +1,12 @@
+chromadb==0.5.7
+google.generativeai
+python-dotenv
+pandas
+numpy
+fastapi
+uvicorn 
+jinja2 
+python-multipart
+pdfplumber
+sentence_transformers
+tiktoken

static/css/styles.css

@@ -0,0 +1,100 @@
+button {
+    /* These styles apply to all buttons */
+    color: white; /* Color of the button text */
+    background-color: rgb(165, 152, 111); /* Background color of the button */
+    border: 2px solid black; /* Border around the button. It's 2px wide, solid, and black */
+    padding: 10px; /* Space between the button text and the edge of the button */
+    width: 200px; /* The button is 200px wide */
+    margin-top: 20px; /* Space between the top of the button and the element above it */
+    border-radius: 10px; /* Rounds the corners of the button */
+    cursor: pointer; /* The cursor turns into a hand when it's over the button */
+    font-family: 'Courier New', Courier, monospace; /* Font of the text. If 'Courier New' isn't available, the browser will try to use 'Courier'. If that's not available, it will use any monospace font. */
+}
+
+.outercontainer {
+    /* These styles apply to the div with class "outercontainer" */
+    max-width: 800px; /* Maximum width of the container. If the screen is narrower than 800px, the container will shrink to fit it */
+    margin: 0 auto; /* Centers the container. 'auto' makes the left and right margins equal */
+    padding: 20px; /* Space between the content of the container and its borders */
+    border: 5px solid #ccc; /* Border around the container. It's 5px wide, solid, and a light grey (#ccc) */
+    border-radius: 50px; /* Rounds the corners of the border */
+}
+
+.conversationcontainer{
+    /* These styles apply to the div with class "conversation" */
+    border: 5px solid #ccc; /* Border around the conversation. It's 5px wide, solid, and a light grey (#ccc) */
+    padding: 10px; /* Space between the content of the conversation and its borders */
+    height: 500px; /* The conversation box is always 500px tall */
+    background-color: #f3f3f3; /* Background color of the conversation */
+    overflow-y: scroll; /* If the conversation gets too tall for its container, it will become scrollable */
+    border-radius: 50px; /* Rounds the corners of the border */
+}
+
+#titlestyle{
+    color: black; /* Color of the heading text */
+    background-color: rgb(227, 224, 212); /* Background color of the heading */
+    border: 2px solid black; /* Border around the heading. It's 2px wide, solid, and black */
+    padding: 10px; /* Space between the content of the heading and its borders */
+    margin-top: 20px; /* Space between the top of the heading and the element above it */
+    border-radius: 10px; /* Rounds the corners of the border */
+    width:fit-content; /* The width of the heading is just enough to fit its content */
+}
+
+#inputtextbox{
+    /* These styles apply to text input fields */
+    width: 85%; /* Text inputs are 85% as wide as their container */
+    border: 5px solid #ccc; /* Border around the text inputs. It's 5px wide, solid, and a light grey (#ccc) */
+    padding: 10px; /* Space between the text in the input and the edge of the input field */
+    background-color: #f3f3f3f3; /* Background color of the text input field */
+    border-radius: 10px; /* Rounds the corners of the text input field */
+}
+
+#submitbutton {
+    /* These styles apply to the submit button */
+    background: url(/static/send-icon.png) no-repeat center center; /* Background image of the button. The image is centered and doesn't repeat */
+    background-size: cover; /* The image covers the entire background of the button */
+    border: none; /* The button has no border */
+    width: 40px; /* The button is 40px wide */
+    height: 40px; /* The button is 40px tall */
+    cursor: pointer; /* The cursor turns into a hand when it's over the button */
+}
+
+.user {
+    /* These styles apply to divs with class "user", i.e., user messages */
+    color: white; /* Color of the user's text */
+    background-color: rgb(0, 195, 255); /* Background color of the user's messages */
+    padding: 8px; /* Space between the user's text and the edge of its container */
+    border-radius: 10px; /* Rounds the corners of the user's messages */
+    float: right; /* Floats the user's messages to the right */
+    clear: both; /* Positions the user's messages below any floated elements that came before it */
+    max-width: 80%; /* Maximum width of the user's messages */
+    margin: 5px;
+}
+
+.bot { 
+    /* Same as above, but for the bot's messages */
+    color: white;
+    background-color: rgb(0, 128, 90);
+    padding: 8px;
+    border-radius: 10px;
+    float: left;
+    clear: both;
+    max-width: 80%;
+    margin: 5px;
+}
+
+.center {
+    /* These styles apply to elements with class "center" */
+    display: flex; /* The center element is a flex container */
+    justify-content: center; /* The items inside the flex container are centered along the horizontal line */
+}
+
+form {
+    /* These styles apply to all forms */
+    margin: 10px; /* Space around the outside of each form */
+}
+
+body {
+    font-family: 'Courier New', Courier, monospace; /* Font of the text. If 'Courier New' isn't available, the browser will try to use 'Courier'. If that's not available, it will use any monospace font. */
+    margin: 50px; /* Space around the outside of the <body> */
+}

templates/index_bye.html

@@ -0,0 +1,21 @@
+<html> 
+    <head>
+        <title>
+            Invite App
+        </title>
+    </head>
+    <body> 
+        <div>
+            <h1>
+                Invite App
+            </h1>
+        </div>
+        <div>
+            <h2>
+                Bye, you are not invited to the event, {{ name_xyz }}
+        
+            </h2>
+        </div>
+
+</body> 
+</html>

templates/index_hello.html

@@ -0,0 +1,21 @@
+<html> 
+    <head>
+        <title>
+            Invite App
+        </title>
+    </head>
+    <body> 
+        <div>
+            <h1>
+                Invite App
+            </h1>
+        </div>
+        <div>
+            <h2>
+                Hello, you are invited to the event, {{ name_xyz }}
+        
+            </h2>
+        </div>
+
+</body> 
+</html>

templates/index_invite.html

@@ -0,0 +1,51 @@
+<html> 
+    <head>
+        <title>
+            Insurance Policy AI Assistant
+        </title>
+        <link rel="stylesheet" type="text/css" href="/static/css/styles.css">
+    </head>
+    <body> 
+        <div class="outercontainer">
+            <div class="center">
+                <h1 id="titlestyle">
+                    Insurance Policy AI Assistant
+                </h1>
+            </div>
+            <div class="conversationcontainer" id="chatcontainer">
+                {% for entry in name_xyz %}
+                <div class="{% if entry.bot %}bot{% else %}user{% endif %}"> 
+                    {% if entry.bot %}
+                    {{ entry.bot|safe }}
+                    {% else %}
+                    {{ entry.user }}
+                    {% endif %}
+                </div>
+                {% endfor %}
+            </div>
+
+            <form action = "/invite" method="POST" class="center">
+                <input type ="text" name="user_input_message" id = "inputtextbox">
+                <input type="submit" value=" " id="submitbutton">
+            </form>
+
+            <form action="/end_conv" method="POST" class="center">
+                <button type="submit">END CONVERSATION</button>
+            </form>
+    </div>
+
+    <script>
+        // Scroll to the bottom of the chat container on page load and after a new message is sent
+        function scrollToBottom() {
+            var chatContainer = document.getElementById('chatcontainer');
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+    
+        window.onload = scrollToBottom;
+
+    </script>
+
+
+
+</body> 
+</html>