added new application files

app.py

@@ -0,0 +1,304 @@
+# Description: This file contains the main Streamlit application for the Resonate project.
+# Run command: streamlit run app.py to run the application
+
+
+import os
+import pandas as pd
+import streamlit as st
+from dotenv import load_dotenv
+from streamlit import session_state as ss
+from streamlit_chat import message 
+from src.clustering.resonate_bert_summarizer import summarize_runner
+from src.clustering.resonate_clustering import Clustering
+from src.langchain.resonate_langchain_functions import LangChain
+from src.utils.resonate_streamlitUtils import (
+    aws_transcribe,
+    convert_video_to_audio,
+    pinecone_init_upsert,
+    transcript_text_editor_minutes_to_hhmmss,
+)
+
+
+def initialize_session_state():
+    # Initialize API keys in session state if not present
+    if "api_keys" not in ss:
+        ss.api_keys = {}
+        ss.api_keys["openai_api_key"] = os.environ.get("OPENAI_API_KEY")
+        ss.api_keys["pinecone_api_key"] = os.environ.get("PINECONE_API_KEY")
+        ss.api_keys["aws_access_key"] = os.environ.get("AWS_ACCESS_KEY")
+        ss.api_keys["aws_secret_access_key"] = os.environ.get("AWS_SECRET_ACCESS_KEY")
+    if "add_meeting" not in ss:
+        ss.add_meeting = False
+    if "Clustering_obj" not in ss:
+        ss.Clustering_obj = Clustering()
+    # Initialize - Main Screen - Transcript Editor
+    if "transcript_speaker_editor" not in ss:
+        ss.transcript_speaker_editor = False
+    if "transcript_text_editor" not in ss:
+        ss.transcript_text_editor = False
+    if "meeting_name" not in ss:
+        ss.meeting_name = ""
+    if "df_transcript_speaker" not in ss:
+        ss.df_transcript_speaker = pd.DataFrame()
+    if "df_transcript_text" not in ss:
+        ss.df_transcript_text = pd.DataFrame()
+    if "updated_df" not in ss:
+        ss.updated_transcript_df_to_embed = pd.DataFrame()
+    if "chat_view" not in ss:
+        ss.chat_view = True
+    if "langchain_obj" not in ss:
+        ss.langchain_obj = LangChain()
+    if "query" not in ss:
+        ss.query = ""
+    if "responses" not in ss:
+        ss["responses"] = ["How can I assist you?"]
+    if "requests" not in ss:
+        ss["requests"] = []
+
+
+def chat_view():
+    st.header("Chat")
+    response_container = st.container()
+    textcontainer = st.container()
+    with textcontainer:
+        query = st.text_input(
+            "Chat Here",
+            placeholder="Message Resonate ... ",
+            value=ss.query,
+            key="query_input",
+        )
+        # Clear button
+        if st.button("Clear"):
+            ss.langchain_obj.conversation_bufw.memory.clear() # Clear conversation buffer
+            ss.query = "" 
+            ss.requests = []
+            ss.responses = []
+            ss["responses"] = ["How can I assist you?"]
+            st.rerun()
+
+        elif query:
+            with st.spinner("typing..."):
+                uuid_list = ss.Clustering_obj.uuid_for_query(query=query)
+                print(f"Meeting Unique ID : {uuid_list}")
+                response = ss.langchain_obj.chat(
+                    query=query, in_filter=uuid_list, complete_db_flag=False
+                )
+                response = response["response"]
+            ss.requests.append(query)
+            ss.responses.append(response)
+            ss.query = ""
+    with response_container:
+        if ss["responses"]:
+            for i in range(len(ss["responses"])):
+                message(ss["responses"][i], key=str(i))
+                if i < len(ss["requests"]):
+                    message(
+                        ss["requests"][i],
+                        is_user=True,
+                        key=str(i) + "_user",
+                    )
+
+
+def api_keys_input():
+    with st.form("keys_input_form"):
+        # Retrieve values from session state
+        openai_api_key = st.text_input(
+            "OpenAPI Key:",
+            type="password",
+            value=ss.api_keys.get(
+                "openai_api_key", ""
+            ),  # Use default value if key is not present
+        )
+        pinecone_api_key = st.text_input(
+            "Pinecone Key:",
+            type="password",
+            value=ss.api_keys.get(
+                "pinecone_api_key", ""
+            ),  # Use default value if key is not present
+        )
+        aws_access_key = st.text_input(
+            "AWS Access Key:",
+            type="password",
+            value=ss.api_keys.get(
+                "aws_access_key", ""
+            ),  # Use default value if key is not present
+        )
+        aws_secret_access_key = st.text_input(
+            "AWS Secret Access Key:",
+            type="password",
+            value=ss.api_keys.get(
+                "aws_secret_access_key", ""
+            ),  # Use default value if key is not present
+        )
+        # Add a button to save the keys
+        save_button = st.form_submit_button("Save API Keys")
+        if save_button:
+            # Update session state with provided keys
+            ss.api_keys["openai_api_key"] = openai_api_key
+            ss.api_keys["pinecone_api_key"] = pinecone_api_key
+            ss.api_keys["aws_access_key"] = aws_access_key
+            ss.api_keys["aws_secret_access_key"] = aws_secret_access_key
+            # Set environment variables only if the keys are not None
+            if openai_api_key:
+                os.environ["OPENAI_API_KEY"] = ss.api_keys["openai_api_key"]
+            if pinecone_api_key:
+                os.environ["PINECONE_API_KEY"] = ss.api_keys["pinecone_api_key"]
+            if aws_access_key:
+                os.environ["AWS_ACCESS_KEY"] = ss.api_keys["aws_access_key"]
+            if aws_secret_access_key:
+                os.environ["AWS_SECRET_ACCESS_KEY"] = ss.api_keys[
+                    "aws_secret_access_key"
+                ]
+            st.rerun()
+
+
+def add_meeting():
+    with st.form("add_meeting_form"):
+        uploaded_file = st.file_uploader("Choose a file", type=["wav", "mp4"])
+        # Get user input
+        meeting_name = st.text_input("Enter Meeting Name:")
+        save_meeting_button = st.form_submit_button("Save Meeting")
+        if save_meeting_button:
+            if not meeting_name:
+                st.warning("Please enter Meeting Name.")
+            elif uploaded_file is None:
+                st.warning("Please upload a meeting recording.")
+            elif meeting_name and uploaded_file:
+                with st.spinner("Processing..."):
+                    file_name = uploaded_file.name.replace(" ", "_")
+                    if file_name.endswith(".mp4") or file_name.endswith(".mpeg4"):
+                        print("in video")
+                        with open("data/videoFiles/" + file_name, "wb") as f:
+                            f.write(uploaded_file.getbuffer())
+                            f.close()
+                        # Convert video file to audio file
+                        audio_path = "data/audioFiles/" + file_name[:-4] + ".wav"
+                        convert_video_to_audio(
+                            "data/videoFiles/" + file_name, audio_path
+                        )
+                        file_name = file_name[:-4] + ".wav"
+                    elif file_name.endswith(".wav"):
+                        print("in audio")
+                        with open("data/audioFiles/" + file_name, "wb") as f:
+                            f.write(uploaded_file.getbuffer())
+                            f.close()
+                    ss.df_transcript_speaker = aws_transcribe(file_name)
+                    ss.meeting_name = meeting_name
+                    ss.transcript_speaker_editor = True
+
+
+def transcript_speaker_editor():
+    ss.add_meeting = False
+    with st.form("transcript_speaker_editor_form"):
+        st.write("Transcript Speaker Editor:")
+        st.dataframe(ss.df_transcript_speaker)
+        df = ss.df_transcript_speaker.copy(deep=True)
+        # Create a list of unique speaker labels
+        speaker_labels = df["speaker_label"].unique()
+        # Create a dictionary to store the updated values
+        updated_speaker_names = {}
+        # Display text input boxes for each speaker label
+        for speaker_label in speaker_labels:
+            new_name = st.text_input(
+                f"Edit speaker label '{speaker_label}'", speaker_label
+            )
+            updated_speaker_names[speaker_label] = new_name
+        # Update the DataFrame with the new speaker label names
+        for old_name, new_name in updated_speaker_names.items():
+            df["speaker_label"] = df["speaker_label"].replace(old_name, new_name)
+        update_speaker_button = st.form_submit_button("Update Speakers")
+    if update_speaker_button and df is not None:
+        ss.df_transcript_speaker = pd.DataFrame()
+        ss.df_transcript_text = df.copy(deep=True)
+        del df
+        ss.transcript_text_editor = True
+        ss.transcript_speaker_editor = False
+        st.rerun()
+
+
+# Function to update the text column
+def transcript_text_editor_update_text(row_index, new_text):
+    ss.updated_transcript_df_to_embed.at[row_index, "text"] = new_text
+
+
+def transcript_text_editor():
+    ss.transcript_speaker_editor = False
+    st.write("Transcript Text Editor:")
+    st.write(ss.df_transcript_text)
+    df = ss.df_transcript_text.copy(deep=True)
+    ss.updated_transcript_df_to_embed = df.copy(deep=True)
+    # Convert start_time and end_time to HH:MM:SS format
+    df["start_time"] = df["start_time"].apply(transcript_text_editor_minutes_to_hhmmss)
+    df["end_time"] = df["end_time"].apply(transcript_text_editor_minutes_to_hhmmss)
+    row_index = st.number_input(
+        "Enter the row index:",
+        min_value=0,
+        max_value=len(df) - 1,
+        value=0,
+        step=1,
+    )
+    new_text = st.text_area("Enter the new text:", df.at[row_index, "text"])
+    update_text_button_inner = st.button("Update Text")
+    if update_text_button_inner:
+        transcript_text_editor_update_text(row_index, new_text)
+        st.success("Text updated successfully!")
+    # Display the updated dataframe
+    st.header("Updated Transcript")
+    st.table(ss.updated_transcript_df_to_embed)
+    update_text_button = st.button("Finish Transcript Editing")
+    if update_text_button:
+        with st.spinner("Uploading..."):
+            ss.df_transcript_text = pd.DataFrame()
+            meeting_summary, meeting_uuid = summarize_runner(
+                ss.updated_transcript_df_to_embed
+            )
+            ss.Clustering_obj.create_Cluster()
+            pinecone_init_upsert(
+                ss.updated_transcript_df_to_embed,
+                meeting_title=ss.meeting_name,
+                meeting_summary=meeting_summary,
+                meeting_uuid=meeting_uuid,
+            )
+            ss.meeting_name = "unnamed"
+            st.success("Pinecone upsert completed successfully!")
+            ss.transcript_text_editor = False
+            ss.updated_transcript_df_to_embed = pd.DataFrame()
+            ss.chat_view = True
+            st.rerun()
+
+
+def init_streamlit():
+    load_dotenv("./config/.env")
+    initialize_session_state()
+    # Set initial state of the sidebar
+    if ss.api_keys["pinecone_api_key"] is not None:
+        st.set_page_config(
+            initial_sidebar_state="collapsed",
+            layout="wide",
+        )
+    st.title("RESONATE")
+    # Initializing sidebar and its components
+    with st.sidebar:
+        api_keys_input()
+    if st.button("Upload Meeting / Chat"):
+        ss.add_meeting = not ss.add_meeting
+        ss.chat_view = not ss.chat_view
+        ss.transcript_speaker_editor = False
+        ss.transcript_text_editor = False
+    if ss.add_meeting:
+        add_meeting()
+    if ss.transcript_speaker_editor:
+        transcript_speaker_editor()
+    if ss.df_transcript_text is not None and ss.transcript_text_editor:
+        transcript_text_editor()
+    if ss.chat_view:
+        chat_view()  # Chat view
+
+
+if __name__ == "__main__":
+    init_streamlit()
+
+# Test questions:
+# What was discussed about cyberbullying?
+# What is one new feature planned for GitLab's code search?
+# What is the goal of defining maintainability for the new diffs architecture?

requirements.txt

@@ -0,0 +1,29 @@
+# Core
+numpy
+pandas
+tqdm
+ipykernel
+boto3
+botocore
+jupyter
+ipywidgets
+python-dotenv
+scikit-learn
+torch
+
+# Project Specific
+openai
+langchain-community
+langchain-openai
+langchain
+pinecone-client
+streamlit
+tiktoken
+webvtt-py
+moviepy
+transformers
+streamlit_chat==0.0.2.2
+faiss-cpu
+
+# LLM Eval
+# trulens

src/aws/resonate_aws_functions.py

@@ -0,0 +1,369 @@
+# Description: AWS utility functions for Resonate. This file contains the code to parse the AWS Transcribe output.
+# Documentation: https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/transcribe/client/start_transcription_job.html
+
+import json
+import os
+import re
+import time
+import boto3
+import dotenv
+import pandas as pd
+import webvtt
+from datetime import datetime
+from IPython.display import HTML, display
+
+class resonate_aws_transcribe:
+    def create_client(
+        self,
+        aws_access_key: str,
+        aws_secret_access_key: str,
+        aws_region_name: str,
+    ) -> tuple[boto3.client, boto3.client]:
+        """
+        Create and return AWS Transcribe and S3 clients with the specified AWS region.
+        """
+        session = boto3.Session(
+            aws_access_key_id=aws_access_key,
+            aws_secret_access_key=aws_secret_access_key,
+            region_name=aws_region_name,
+        )
+        return session.client("transcribe"), session.client("s3")
+
+    def create_s3_bucket(
+        self, s3: boto3.client, bucket_name: str, aws_region_name: str
+    ) -> bool:
+        """
+        Create an S3 bucket using the provided AWS S3 client if it doesn't exist.
+        """
+        try:
+            s3.create_bucket(
+                Bucket=bucket_name,
+                CreateBucketConfiguration={"LocationConstraint": aws_region_name},
+            )
+            print(f"S3 bucket '{bucket_name}' created successfully.")
+            return True
+        except s3.exceptions.BucketAlreadyExists:
+            print(f"S3 bucket '{bucket_name}' already exists.")
+            return True
+        except Exception as e:
+            print(f"Error creating S3 bucket '{bucket_name}': {e}")
+            return False
+
+    def upload_to_s3(
+        self, s3: boto3.client, file_path: str, bucket_name: str, object_name=None
+    ) -> str:
+        """
+        Upload the audio file to S3 bucket using the provided AWS S3 client.
+        """
+        if object_name is None:
+            object_name = file_path
+
+        try:
+            s3.upload_file(file_path, bucket_name, object_name)
+            uri = f"s3://{bucket_name}/{object_name}"
+            print(f"File '{file_path}' uploaded successfully to '{uri}'")
+            return uri
+
+        except Exception as e:
+            print(
+                f"Error uploading file '{file_path}' to '{bucket_name}/{object_name}': {e}"
+            )
+            return ""
+
+    def download_from_s3(
+        self,
+        s3: boto3.client,
+        object_name: str,
+        bucket_name: str,
+        local_directory: str,
+    ) -> bool:
+        """
+        Download the .json and .vtt files from an S3 bucket to a local directory.
+        """
+        local_file_json = f"{local_directory}/{object_name}.json"
+        local_file_vtt = f"{local_directory}/{object_name}.vtt"
+
+        try:
+            s3.download_file(bucket_name, object_name + ".json", local_file_json)
+            print(f"File '{object_name}' (JSON) downloaded successfully to '{local_file_json}'")
+
+            s3.download_file(bucket_name, object_name + ".vtt", local_file_vtt)
+            print(f"File '{object_name}' (VTT) downloaded successfully to '{local_file_vtt}'")
+            return True
+        except Exception as e:
+            print(f"Error downloading file '{object_name}' from '{bucket_name}': {e}")
+            return False
+
+    def delete_from_s3(
+        self, s3: boto3.client, bucket_name: str, object_name: str
+    ) -> bool:
+        """
+        Delete the file from an S3 bucket using the provided AWS S3 client.
+        """
+        try:
+            s3.delete_object(Bucket=bucket_name, Key=object_name)
+            print(f"File '{object_name}' deleted successfully from '{bucket_name}'")
+            return True
+        except Exception as e:
+            print(f"Error deleting file '{object_name}' from '{bucket_name}': {e}")
+            return False
+
+    def delete_s3_bucket(self, s3: boto3.client, bucket_name: str) -> bool:
+        """
+        Delete a S3 bucket along with its contents using the provided AWS S3 client.
+        """
+        try:
+            objects = s3.list_objects(Bucket=bucket_name).get("Contents", [])
+            for obj in objects:
+                s3.delete_object(Bucket=bucket_name, Key=obj["Key"])
+                print(
+                    f"Object '{obj['Key']}' deleted successfully from '{bucket_name}'"
+                )
+
+            s3.delete_bucket(Bucket=bucket_name)
+            print(f"S3 bucket '{bucket_name}' and its contents deleted successfully.")
+            return True
+        except Exception as e:
+            return e
+
+    def transcribe_audio(
+        self,
+        transcribe_client: boto3.client,
+        uri: str,
+        output_bucket: str,
+        transcribe_job_name: str = "job",
+    ) -> dict:
+        """
+        Start a transcription job for audio stored in an S3 bucket using the AWS Transcribe service.
+        """
+        print("Calling AWS Transcribe Job...")
+        response = transcribe_client.start_transcription_job(
+            TranscriptionJobName=transcribe_job_name,
+            LanguageCode="en-US",
+            MediaFormat="wav",
+            Settings={
+                "ShowSpeakerLabels": True,
+                "MaxSpeakerLabels": 10,
+                "ChannelIdentification": False,
+            },
+            Media={"MediaFileUri": uri},
+            Subtitles={"Formats": ["vtt"]},
+            OutputBucketName=output_bucket,
+        )
+        return response
+
+    def combine_files(self, file_name: str, local_directory: str) -> pd.DataFrame:
+        """
+        Combines information from a JSON file and a WebVTT file into a CSV file.
+        """
+        json_file_path = f"{local_directory}/{file_name}.json"
+        with open(json_file_path, "r") as f:
+            data = json.load(f)
+
+        segments = data["results"]["speaker_labels"]["segments"]
+        df = pd.DataFrame(segments)
+        df["start_time"] = df["start_time"].astype(float) / 60
+        df["end_time"] = df["end_time"].astype(float) / 60
+        df = df.rename(
+            columns={
+                "start_time": "start_time",
+                "end_time": "end_time",
+                "speaker_label": "speaker_label",
+            }
+        )
+
+        vtt_file_path = f"{local_directory}/{file_name}.vtt"
+        subtitles = webvtt.read(vtt_file_path)
+
+        data = [
+            (
+                subtitle.start_in_seconds / 60,
+                subtitle.end_in_seconds / 60,
+                subtitle.text.strip(),
+            )
+            for subtitle in subtitles
+        ]
+        titles = pd.DataFrame(data, columns=["start_time", "end_time", "text"])
+        transcript = pd.merge_asof(
+            titles.sort_values("start_time"),
+            df.sort_values("start_time"),
+            on="start_time",
+            direction="backward",
+        )
+
+        transcript = transcript.dropna(subset=["speaker_label"])
+        transcript = transcript[["start_time", "end_time_x", "speaker_label", "text"]]
+        transcript.columns = ["start_time", "end_time", "speaker_label", "text"]
+
+        # Reset the index
+        transcript = transcript.reset_index(drop=True)
+
+        print("Combined transcript successfully!")
+        return transcript
+
+    def aws_transcribe_parser(
+        self, transcript_df: pd.DataFrame, output_filename: str
+    ) -> pd.DataFrame:
+        """
+        Parses the AWS Transcribe output by cleaning duplicate texts and merging consecutive rows with
+        the same speaker.
+        """
+        prev_text = None  # Initialize prev_text
+        transcript_df["text"] = transcript_df["text"].apply(
+            lambda x: re.sub(r"[\"\'\--]+", "", x)
+        )
+
+        for index, row in transcript_df.iterrows():
+            if row["text"] == prev_text and row["speaker_label"] == prev_speaker:
+                transcript_df.at[merge_start, "end_time"] = row["end_time"]
+                transcript_df.drop(index, inplace=True)
+            else:
+                merge_start = index
+
+            prev_text = row["text"]
+            prev_speaker = row["speaker_label"]
+
+        transcript_df["group"] = (
+            transcript_df["speaker_label"] != transcript_df["speaker_label"].shift()
+        ).cumsum()
+        result_df = transcript_df.groupby(
+            ["group", "speaker_label"], as_index=False
+        ).agg({"start_time": "first", "end_time": "last", "text": " ".join})
+        result_df = result_df.drop(columns=["group"])
+
+        result_df.to_csv(
+            "./data/transcriptFiles/" + output_filename + ".csv", index=False
+        )
+        return result_df
+
+    def delete_local_temp_file(self, tempFiles: str) -> bool:
+        """
+        Delete a local temporary file specified by the file path.
+        """
+        if os.path.exists("./data/tempFiles/" + tempFiles + ".json"):
+            os.remove("./data/tempFiles/" + tempFiles + ".json")
+
+        if os.path.exists("./data/tempFiles/" + tempFiles + ".vtt"):
+            os.remove("./data/tempFiles/" + tempFiles + ".vtt")
+
+    def runner(
+        self,
+        file_name: str,
+        input_bucket: str,
+        output_bucket: str,
+        transcribe_job_name: str,
+        aws_access_key: str,
+        aws_secret_access_key: str,
+        aws_region_name: str,
+    ) -> None:
+        """
+        Run the transcription process for an audio file using AWS Transcribe.
+        """
+        transcribe_client, s3_client = self.create_client(
+            aws_access_key=aws_access_key,
+            aws_secret_access_key=aws_secret_access_key,
+            aws_region_name=aws_region_name,
+        )
+
+        print("Transcribe_client created: ", transcribe_client)
+        print("s3_client created: ", s3_client)
+
+        # Create S3 buckets
+        print(
+            f"Create S3 Bucket {input_bucket} : ",
+            self.create_s3_bucket(s3_client, input_bucket, aws_region_name),
+        )
+        print(
+            f"Create S3 Bucket {output_bucket} : ",
+            self.create_s3_bucket(s3_client, output_bucket, aws_region_name),
+        )
+
+        URI = self.upload_to_s3(
+            s3_client, "./data/audioFiles/" + file_name, input_bucket
+        )
+        print("Upload completed now will initiate transcription job.")
+        self.transcribe_audio(
+            transcribe_client,
+            URI,
+            output_bucket,
+            transcribe_job_name=transcribe_job_name,
+        )
+
+        # Check status of transcription job
+        while (
+            transcribe_client.get_transcription_job(
+                TranscriptionJobName=transcribe_job_name
+            )["TranscriptionJob"]["TranscriptionJobStatus"]
+            != "COMPLETED"
+        ):
+            time.sleep(3)
+
+        # Download transcription job output
+        print(
+            "Download from S3 : ",
+            self.download_from_s3(
+                s3_client,
+                transcribe_job_name,
+                output_bucket,
+                local_directory="./data/tempFiles/",
+            ),
+        )
+
+        print(
+            "Delete S3 Bucket Input Bucket : ",
+            self.delete_s3_bucket(s3_client, input_bucket),
+        )
+        print(
+            "Delete S3 Bucket Output Bucket: ",
+            self.delete_s3_bucket(s3_client, output_bucket),
+        )
+
+        try:
+            transcribe_client.delete_transcription_job(
+                TranscriptionJobName=transcribe_job_name
+            )
+        except:
+            print("Transcription Job does not exist.")
+
+        # Close clients
+        transcribe_client.close()
+        s3_client.close()
+
+        # combine the json and vtt results to create a transcript
+        df_transcript_combined = self.combine_files(
+            transcribe_job_name, local_directory="./data/tempFiles/"
+        )  
+        df_transcript_combined_parsed = self.aws_transcribe_parser(
+            transcript_df=df_transcript_combined, output_filename=transcribe_job_name
+        )
+        print("Transcript parsed successfully")
+
+        self.delete_local_temp_file(tempFiles=transcribe_job_name)
+        return df_transcript_combined_parsed
+
+
+if __name__ == "__main__":
+    dotenv.load_dotenv("./config/.env")
+
+    current_timestamp = str.lower(datetime.now().strftime("%Y-%b-%d-%I-%M-%p"))
+
+    aws_access_key = os.getenv("AWS_ACCESS_KEY")
+    aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+    print(aws_access_key, aws_secret_access_key)
+    aws_region_name = "us-east-2"
+    file_name = "test.wav"
+    input_bucket = f"resonate-input-{str(current_timestamp)}"
+    output_bucket = f"resonate-output-{str(current_timestamp)}"
+    transcribe_job_name = f"resonate-job-{str(current_timestamp)}"
+
+    rat = resonate_aws_transcribe()
+    df = rat.runner(
+        file_name=file_name,
+        input_bucket=input_bucket,
+        output_bucket=output_bucket,
+        transcribe_job_name=transcribe_job_name,
+        aws_access_key=aws_access_key,
+        aws_secret_access_key=aws_secret_access_key,
+        aws_region_name=aws_region_name,
+    )
+    print(df)

src/clustering/resonate_bert_summarizer.py

@@ -0,0 +1,96 @@
+# Description: The code helps generate abstractive summary for the transcript data using BART model
+# Reference: https://huggingface.co/vmarklynn/bart-large-cnn-samsum-acsi-ami-v2
+# Reference : https://github.com/vmarklynn/parrot/blob/main/notebooks/summarizer.ipynb
+
+import math
+import pandas as pd
+import os
+import uuid
+from transformers import pipeline
+
+# Initialization of summarizer based on Bart
+MODEL = 'vmarklynn/bart-large-cnn-samsum-acsi-ami-v2'
+summarizer = pipeline("summarization", MODEL, truncation=True)
+
+def format_text(text):
+    '''
+    Format the transcript data into a readable format
+    '''
+    try:
+        formatted_data = [
+            f"{row['speaker_label']}: {row['text']}" for _, row in text.iterrows()
+        ]
+        formatted_text = "\n".join([f"{line}" for line in formatted_data])
+        return formatted_text
+    except Exception as e:
+        print(f"Error formatting text: {e}")
+        return ""
+
+
+def summarize_text(transcript):
+    '''
+    Summarize the text using the BART model
+    '''
+    try:
+        text = format_text(transcript)
+
+        print("\n\nSummarizing Text...")
+        summary = summarizer(text)[0]["summary_text"]
+        response = {"transcription": format_text, "summary": summary}
+        return response
+    except Exception as e:
+        print(f"Error summarizing text: {e}")
+        return {}
+
+
+def summarize_summary(summary_input):
+    '''
+    Summarize the summarized text using the BART model
+    '''
+    try:
+        word_count = 1024 
+        summary = summarizer(
+            summary_input,
+            min_length=math.ceil(int(word_count) * 0.1),
+            max_length=math.ceil(int(word_count) * 0.25),
+        )[0]["summary_text"]
+        response = {"summary": summary}
+        return response
+    except Exception as e:
+        print(f"Error summarizing summary: {e}")
+        return {}
+
+
+def append_summary_to_csv(summary_text):
+    try:
+        csv_filename = "./data/summaryFiles/abstract_summary_data.csv"
+        meeting_uuid = str(uuid.uuid4())
+        if os.path.exists(csv_filename):
+            df = pd.read_csv(csv_filename)
+        else:
+            df = pd.DataFrame(columns=["uuid", "text"])
+        new_data = pd.DataFrame({"uuid": [meeting_uuid], "text": [summary_text]})
+        df = pd.concat([df, new_data], ignore_index=True)
+
+        df.to_csv(csv_filename, index=False)
+        return meeting_uuid
+    except Exception as e:
+        print(f"Error appending summary to CSV: {e}")
+        return False
+
+
+def summarize_runner(transcript):
+    try:
+        transcript.drop(["end_time"], axis=1, inplace=True)
+        summary_transcript = summarize_text(transcript)
+        summarized_summary = summarize_summary(summary_transcript["summary"])
+        final_summary = summarized_summary["summary"]
+        meeting_uuid = append_summary_to_csv(final_summary)
+    except Exception as e:
+        print(f"Error in summarize_runner: {e}")
+    return final_summary, meeting_uuid
+
+
+if __name__ == "__main__":
+    df = pd.read_csv("./data/transcriptFiles/Social_Media_-_Ruins_your_life.csv")
+    summarize_runner(df)

src/clustering/resonate_clustering.py

@@ -0,0 +1,179 @@
+# Description:Creates clusters based on the uploaded transcripts and returns the uuid of the documents that are similar to the query.
+# Reference Code: https://github.com/chakib401/smoothing_sentence_embeddings/blob/master/utils.py
+
+'''
+Paper Citation for def normalize_adj(): 
+Fettal, Chakib, Lazhar Labiod, and Mohamed Nadif. 
+"More Discriminative Sentence Embeddings via Semantic Graph Smoothing." 
+arXiv preprint arXiv:2402.12890 (2024).
+'''
+
+import json
+import os
+import joblib
+import numpy as np
+import pandas as pd
+import scipy.sparse as sp
+import src.clustering.resonate_semantic_search as SemanticSearch
+from dotenv import load_dotenv
+from langchain_openai import OpenAIEmbeddings
+from scipy.io import loadmat, savemat
+from sklearn.cluster import MeanShift, estimate_bandwidth
+from sklearn.neighbors import kneighbors_graph
+
+def normalize_adj(adj, lmbda=1):
+    '''
+    Normalize adjacency matrix of semantic graph
+    '''
+    adj = adj + lmbda * sp.eye(adj.shape[0])
+    rowsum = np.array(adj.sum(1))
+    r_inv = np.power(rowsum, -1).flatten()
+    r_inv[np.isinf(r_inv)] = 0.0
+    r_mat_inv = sp.diags(r_inv)
+    adj = r_mat_inv.dot(adj)
+
+    adj = adj + lmbda * sp.eye(adj.shape[0])
+    adj = sp.coo_matrix(adj)
+    row_sum = np.array(adj.sum(1))
+    d_inv_sqrt = np.power(row_sum, -0.5).flatten()
+    d_inv_sqrt[np.isinf(d_inv_sqrt)] = 0.0
+    d_mat_inv_sqrt = sp.diags(d_inv_sqrt)
+    return d_mat_inv_sqrt.dot(adj).dot(d_mat_inv_sqrt).tocoo()
+
+
+def graph_filtering(features, degree=2, lmbda=1, nn=10, alpha=0.5, t=5, method="sgc"):
+    """
+    This function will perform graph filtering based on four polynomial filters
+    We keep n=10, as per paper. And is used to calculate the graph (adjacency matrix)
+    between 10 vectors/features.
+
+    **That is why we have 10 pre-existing transcripts placed in pinecone (through the ont_time_script)
+    **If you want to change the number of transcripts, you will have to change the number of neighbors
+    """
+    adj = kneighbors_graph(features, n_neighbors=nn, metric="cosine")
+    adj = (adj + adj.T) / 2
+
+    S = normalize_adj(adj, lmbda)
+    xx = features
+    yy = features.copy()
+    if method in ["sgc", "s2gc"]:
+        for _ in range(degree):
+            xx = S @ xx
+            yy += xx
+        if method == "sgc":
+            return xx
+        elif method == "s2gc":
+            return yy
+    elif method == "appnp":
+        for _ in range(degree):
+            xx = (1 - alpha) * S @ xx + alpha * features
+        return xx
+    elif method == "dgc":
+        k = degree + 1
+        for _ in range(1, degree + 1):
+            xx = (1 - t / k) * xx + (t / k) * (S @ xx)
+        return xx
+    else:
+        raise "unrecognized filter"
+
+
+def load_json_config(json_file_path="./config/config.json"):
+    with open(json_file_path, "r") as file:
+        data = json.load(file)
+    return data
+
+
+class Clustering:
+    def __init__(self):
+        self.api_key = os.environ.get("OPENAI_API_KEY")
+        self.method = "dgc"
+
+        if not os.path.exists("./data/clusteringFiles/cluster_data.csv"):
+            self.create_Cluster()
+
+        self.index = self.initialize_FAISS()
+
+    def create_embedding(self):
+        '''This function will perform two task:
+        1. embedding on entire data, abstract_data.csv
+        2. save embeddings in cluster_data-embedding.mat in format uuid, text
+        '''
+        data = pd.read_csv("./data/summaryFiles/abstract_summary_data.csv")
+        json_config = load_json_config()
+
+        text, id = data["text"], data["uuid"]
+        # embedding model
+        embed = OpenAIEmbeddings(
+            model=json_config["EMBEDDING_MODEL_NAME"], openai_api_key=self.api_key
+        )
+        embeddings = embed.embed_documents(text)
+        savemat(
+            "./data/embeddingFiles/cluster-embedding.mat",
+            {"uuid": id, "text": embeddings},
+        )
+
+
+    def create_Cluster(self):
+        '''
+        This function will perform following tasks:
+        1. call embedding function
+        2. form clusters using cluste_data-embedding.mat file
+        3. Save predicted labels in cluster_data.csv
+        '''
+        self.create_embedding()
+
+        data = loadmat("./data/embeddingFiles/cluster-embedding.mat")
+        features1 = data["text"]
+
+        features = graph_filtering(features1, method=self.method)
+        ibandwidth = estimate_bandwidth(features, quantile=0.30, random_state=42)
+        msclustering = MeanShift(bandwidth=ibandwidth, max_iter=900)
+        msclustering.fit(features)
+        model_path = f"./data/clusteringFiles/{self.method}_model.joblib"
+        joblib.dump(msclustering, model_path)
+
+        print("Model saved")
+
+        df = pd.read_csv(f"./data/summaryFiles/abstract_summary_data.csv")
+        df["cluster"] = msclustering.predict(features)
+        df.to_csv("./data/clusteringFiles/cluster_data.csv")
+        print("Cluster data saved")
+        self.index = self.initialize_FAISS()
+
+
+
+    def uuid_for_query(self, query):
+        '''
+        Returns the uuids of the documents that are similar to the query, based on the clustering
+        '''
+        query_cluster_label = self.index.search_query(query)
+        print(f"Predicted Label : {query_cluster_label[0]}")
+        df = pd.read_csv("./data/clusteringFiles/cluster_data.csv")
+        filtered_uuids = df[df["cluster"] == query_cluster_label[0]]["uuid"].tolist()
+        return filtered_uuids
+
+    def initialize_FAISS(self):
+        model = SemanticSearch.SemanticEmbedding()
+        index = SemanticSearch.FaissForQuerySearch(model)
+        data = pd.read_csv("./data/clusteringFiles/cluster_data.csv")
+        features1 = data["text"]
+        uuids = data["uuid"]
+        labels = data["cluster"]
+        for text, uuid, label in zip(features1, uuids, labels):
+            index.add_summary(text, uuid, label)
+        return index
+
+
+if __name__ == "__main__":
+    load_dotenv("./config/.env")
+    Clustering_obj = Clustering()
+    print(
+        Clustering_obj.uuid_for_query(
+            "What is the goal of defining maintainability for the new diffs architecture?"
+        )
+    )
+    print(
+        Clustering_obj.uuid_for_query(
+            "What was the design component for remote control?"
+        )
+    )

src/clustering/resonate_semantic_search.py

@@ -0,0 +1,66 @@
+# Description: Using Facebook's Faiss library to perform semantic search according to the query
+# Reference: https://deepnote.com/blog/semantic-search-using-faiss-and-mpnet
+
+from transformers import AutoTokenizer, AutoModel
+import torch
+import torch.nn.functional as F
+import faiss
+
+class SemanticEmbedding:
+
+    def __init__(self, model_name="sentence-transformers/all-mpnet-base-v2"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+
+    # Mean Pooling - Take attention mask into account for correct averaging
+    def mean_pooling(self, model_output, attention_mask):
+        token_embeddings = model_output[
+            0
+        ]  # First element of model_output contains all token embeddings
+        input_mask_expanded = (
+            attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        )
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(
+            input_mask_expanded.sum(1), min=1e-9
+        )
+
+    def get_embedding(self, sentences):
+        # Tokenize sentences
+        encoded_input = self.tokenizer(
+            sentences, padding=True, truncation=True, return_tensors="pt"
+        )
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        # Perform pooling
+        sentence_embeddings = self.mean_pooling(
+            model_output, encoded_input["attention_mask"]
+        )
+
+        # Normalize embeddings
+        sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1)
+        return sentence_embeddings.detach().numpy()
+
+
+class FaissForQuerySearch:
+
+    def __init__(self, model, dim=768):
+        self.index = faiss.IndexFlatIP(dim)
+        # Maintaining the document data
+        self.doc_map = dict()
+        self.model = model
+        self.ctr = 0
+        self.uuid = []
+        self.labels = []
+
+    def search_query(self, query, k=1):
+        D, I = self.index.search(self.model.get_embedding(query), k)
+        return [
+            self.labels[idx] for idx, score in zip(I[0], D[0]) if idx in self.doc_map
+        ]
+
+    def add_summary(self, document_text, id, predicted_label):
+        self.index.add((self.model.get_embedding(document_text)))  # index
+        self.uuid.append(id)  # appending the uuid
+        self.labels.append(predicted_label)  # appending the predicted label
+        self.doc_map[self.ctr] = document_text  # store the original document text
+        self.ctr += 1

src/langchain/resonate_langchain_functions.py

@@ -0,0 +1,148 @@
+#Description: This file contains the LangChain class which is used to query the pinecone and chatbot
+
+import os
+import json
+from src.pinecone.resonate_pinecone_functions import PineconeServerless
+from langchain_community.callbacks import get_openai_callback
+from dotenv import load_dotenv
+from datetime import datetime
+from langchain_openai import ChatOpenAI
+from langchain.chains import ConversationChain
+from langchain.chains.conversation.memory import (
+    ConversationSummaryBufferMemory,
+)
+from langchain.prompts.chat import (
+    HumanMessagePromptTemplate,
+    ChatPromptTemplate,
+    SystemMessagePromptTemplate,
+)
+
+def load_json_config(json_file_path="./config/config.json"):
+    with open(json_file_path, "r") as file:
+        data = json.load(file)
+    return data
+
+
+class LangChain:
+    def __init__(self):
+
+        json_config = load_json_config()
+        # check if the .env file exists using os
+        if os.path.exists("./config/.env"):
+            load_dotenv("./config/.env")
+
+        self.PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+        self.OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+        print("PINECONE_API_KEY: ", self.PINECONE_API_KEY)
+        if self.PINECONE_API_KEY and self.OPENAI_API_KEY :
+            self.pinecone = PineconeServerless()
+            print("INSIDE PINECONE")
+            self.llm_temperature = json_config["LC_LLM_TEMPERATURE"]
+            self.llm_model = json_config["LC_LLM_MODEL"]
+            self.llm_summary_max_token_limit = json_config[
+                "LC_LLM_SUMMARY_MAX_TOKEN_LIMIT"
+            ]
+            self.llm_conv_buffer_memory_window = json_config[
+                "LC_CONV_BUFFER_MEMORY_WINDOW"
+            ]
+
+            self.llm = ChatOpenAI(
+                temperature=self.llm_temperature,
+                model_name=self.llm_model,
+                streaming=False,
+            )
+
+            self.conversation_bufw = ConversationChain(
+                llm=self.llm,
+                memory=ConversationSummaryBufferMemory(
+                    llm=self.llm, max_token_limit=self.llm_summary_max_token_limit
+                ),
+            )
+
+    def prompt(self, query, context):
+
+        system_template = SystemMessagePromptTemplate.from_template(
+            "As a helpful assistant, your task is to provide concise and relevant answers based on the given context, which consists of a transcript excerpt from a meeting. The format of the context is as follows:"
+            "\nConversations in meeting: <meeting_title>, <meeting_date>"
+            "\nStart Time - Speaker: Text"
+            "\nYou may receive multiple meeting transcripts, if you feel your response requires reference to multiple meetings, feel free to mention <meeting_title> in your response."
+            "Your responses should strictly adhere to the provided context. If you cannot find an answer within the given context, you may ask the user for more information. Ensure clarity by referencing the meeting_title, meeting_date, and speaker as needed."
+            "Your responses should be succinct and directly address the user query using the context provided. Avoid discussing any information beyond the given context or using external sources."
+            "Skip unnecessary phrases like 'Based on the context provided' and focus solely on answering the users query. No need for greetings or farewells."
+            "\nContext:\n"
+            "{context}"
+        )
+
+        human_template = HumanMessagePromptTemplate.from_template("\nUser Query: {input}")
+        chat_prompt = ChatPromptTemplate.from_messages(
+            [system_template, human_template]
+        )
+        chat_prompt_value = chat_prompt.format_prompt(context=context, input=query)
+        return chat_prompt_value.to_messages()
+
+
+    def query_chatbot(self, query, context):
+        '''
+        Query the chatbot with the given query and context
+        '''
+        self.messages = self.prompt(query, context)
+        #print("Complete msg passed to LLM: \n"self.messages)
+        #print("CONTEXT: \n", self.messages)
+        resp = self.conversation_bufw(self.messages)
+        return resp
+
+    def parse_conversations(self, conversations) -> str:
+        ''''
+        Parse the conversations and return the data in a readable format
+        '''
+        '''
+        Format:
+        Conversations in meeting: <meeting_title1>
+        Start Time - Speaker: Text
+        Start Time - Speaker: Text
+        .
+        .
+        \n\n
+        Conversations in meeting: <meeting_title2>
+        Start Time - Speaker: Text
+        Start Time - Speaker: Text
+        .
+        .
+        '''
+        data = []
+        for cluster_id, cluster_df in conversations.items():
+            with open(f"./data/jsonMetaDataFiles/{cluster_id}.json") as f:
+                meeting_data = json.load(f)
+                meeting_title = meeting_data["meeting_title"]
+                meeting_date = datetime.strptime(meeting_data["meeting_date"], '%Y%m%d%H%M%S').strftime('%Y-%m-%d %H:%M:%S')
+                data.append(f"Conversations in meeting: '{meeting_title}', meeting_date: {meeting_date} :")
+                for i, row in cluster_df.iterrows():
+                    data.append(
+                        f"{row['start_time']} - {row['speaker']}: {row['text']}"
+                    )
+                data.append("\n\n")
+        data = "\n".join(data)
+        return data
+
+    def chat(self, query, in_filter: list[str] = [], complete_db_flag: bool = False):
+        '''
+        Primary chat function to query the pinecone and chatbot
+        If in_filter is provided, the query will be filtered based on the in_filter
+        If complete_db_flag is True, the query will be searched in the complete database
+        '''
+        # if "summary" in query:
+        #     pass # Future implementation, using semantic routing
+
+        self.pinecone.query_pinecone(query, in_filter, complete_db_flag)
+        conversation = self.pinecone.query_delta_conversations()
+        # print("Conversation: ", conversation)
+        context = self.parse_conversations(conversation)
+        print("Context: ", context)
+        response = self.query_chatbot(query, context)
+        return response
+
+    def count_tokens(self, chain, query):
+        with get_openai_callback() as callback:
+            response = chain(query)
+            print(f"Call Back:  {callback}")
+        return response

src/pinecone/resonate_pinecone_functions.py

@@ -0,0 +1,422 @@
+# Description: Pinecone Serverless Class for Resonate
+# Reference: https://www.pinecone.io/docs/
+
+import datetime
+import uuid
+import json
+import os
+import time
+import pandas as pd
+from dotenv import load_dotenv
+from langchain_openai import OpenAIEmbeddings
+from pinecone import Pinecone, ServerlessSpec
+
+def load_json_config(json_file_path="./config/config.json"):
+    with open(json_file_path, "r") as file:
+        data = json.load(file)
+    return data
+
+
+class PineconeServerless:
+    def __init__(self) -> None:
+        print("Pinecone Serverless Initializing")
+        json_config = load_json_config()
+        load_dotenv("./config/.env")
+
+        self.PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
+        self.OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+        if self.PINECONE_API_KEY is not None:
+            self.pinecone = Pinecone(api_key=self.PINECONE_API_KEY)
+        self._init_config(json_config)
+        self.meeting_title = None
+        self.base_data_path = "./data/jsonMetaDataFiles/"
+        self.master_json_file = f"{self.base_data_path}{self.master_json_filename}.json"
+        self._create_master_json()
+        self._create_index()
+        self.response = None
+        print("Pinecone Serverless Initialized")
+
+    def _init_config(self, json_config) -> None:
+        for key, value in json_config.items():
+            setattr(self, key.lower(), value)
+
+    def check_index_already_exists(self) -> bool:
+        return self.pinecone_index_name in self.pinecone.list_indexes()
+
+    def _get_vector_embedder(self):
+        if self.embedding_provider == "OpenAI":
+            return OpenAIEmbeddings(model=self.embedding_model_name)
+        else:
+            raise ValueError("Invalid Embedding Model")
+
+    def _get_index(self):
+        return self.pinecone.Index(self.pinecone_index_name)
+
+    def _create_index(self) -> None:
+        '''
+        Creates a new index in Pinecone if it does not exist
+        '''
+        pinecone_indexes_list = [
+            index.get("name")
+            for index in self.pinecone.list_indexes().get("indexes", [])]
+
+        if self.pinecone_index_name not in pinecone_indexes_list:
+            try:
+                self.pinecone.create_index(
+                    name=self.pinecone_index_name,
+                    metric=self.pinecone_metric,
+                    dimension=self.pinecone_vector_dimension,
+                    spec=ServerlessSpec(
+                        cloud=self.pinecone_cloud_provider,
+                        region=self.pinecone_region,
+                        # pod_type="p1.x1", # Future use
+                    ),
+                )
+
+                while not self.pinecone.describe_index(self.pinecone_index_name).status["ready"]:
+                    time.sleep(5)
+
+            except Exception as e:
+                print("Index creation failed: ", e)
+
+    def describe_index_stats(self) -> dict:
+        try:
+            index = self._get_index()
+            return index.describe_index_stats()
+        except Exception as e:
+            print("Index does not exist: ", e)
+            return {}
+
+    def _delete_index(self) -> None:
+        try:
+            self.pinecone.delete_index(self.pinecone_index_name)
+        except Exception as e:
+            print("Index does not exist: ", e)
+
+    def _create_master_json(self) -> None:
+        '''
+        Check if the master json file exists, if not, create it
+        '''
+        os.makedirs(os.path.dirname(self.base_data_path), exist_ok=True)
+        if not os.path.exists(self.master_json_file):
+            with open(self.master_json_file, "w") as file:
+                data = {
+                    "index": self.pinecone_index_name,
+                    "namespace": self.pinecone_namespace,
+                    "last_conversation_no": 0,
+                    "meeting_uuids": [],
+                    "meetings": [],
+                }
+
+                with open(self.master_json_file, "w") as f:
+                    json.dump(data, f, indent=4)
+
+                print(f"Created {self.master_json_file}")
+
+    def _update_master_json(
+        self,
+        meeting_uuid: str,
+        meeting_title: str,
+        last_conversation_no: int,
+        meeting_video_file: bool,
+        time_stamp: str,
+    ) -> dict:
+        '''
+        Updates the master json file with the new meeting details
+        '''
+        with open(self.master_json_file, "r+") as f:
+            data = json.load(f)
+            data["meeting_uuids"] = list(set(data["meeting_uuids"] + [meeting_uuid]))
+            data["last_conversation_no"] = last_conversation_no
+            data["meetings"].append(
+                {
+                    "meeting_uuid": meeting_uuid,
+                    "meeting_title": meeting_title,
+                    "meeting_date": time_stamp,
+                    "meeting_video_file": meeting_video_file,
+                }
+            )
+            return data
+
+    def _get_meeting_members(self, transcript: pd.DataFrame) -> list[str]:
+        return list(transcript["speaker_label"].unique())
+
+    def _create_new_meeting_json(
+        self,
+        meeting_uuid: str,
+        meeting_title: str,
+        last_conversation_no: int,
+        meeting_members: list[str],
+        meeting_video_file: bool,
+        time_stamp: str,
+        meeting_summary: str,
+    ) -> dict:
+        '''
+        Creates a new json file for the meeting details
+        '''
+        data = {
+            "index": self.pinecone_index_name,
+            "namespace": self.pinecone_namespace,
+            "meeting_title": meeting_title,
+            "meeting_uuid": meeting_uuid,
+            "meeting_date": time_stamp,
+            "last_conversation_no": last_conversation_no,
+            "meeting_video_file": meeting_video_file,
+            "meeting_members": meeting_members,
+            "meeting_summary": meeting_summary,
+        }
+
+        meeting_details_file = os.path.join(self.base_data_path, f"{meeting_uuid}.json")
+        with open(meeting_details_file, "w") as f:
+            json.dump(data, f, indent=4)
+
+    def _get_last_conversation_no(self) -> list[str]:
+
+        with open(self.master_json_file, "r") as f:
+            data = json.load(f)
+
+            return data["last_conversation_no"]
+
+    def _set_new_meeting_json(
+        self,
+        meeting_uuid: str,
+        meeting_title: str,
+        last_conversation_no: str,
+        meeting_members: list[str],
+        meeting_video_file: bool,
+        meeting_summary: str,
+    ) -> dict:
+        '''
+        Updates the master json file with the new meeting details
+        '''
+        time_stamp = str(datetime.datetime.now().strftime("%Y%m%d%H%M%S"))
+        self._create_new_meeting_json(
+            meeting_uuid,
+            meeting_title,
+            last_conversation_no,
+            meeting_members,
+            meeting_video_file,
+            time_stamp,
+            meeting_summary,
+        )
+        data = self._update_master_json(
+            meeting_uuid,
+            meeting_title,
+            last_conversation_no,
+            meeting_video_file,
+            time_stamp,
+        )
+
+        with open(self.master_json_file, "w") as f:
+            json.dump(data, f, indent=4)
+
+    def _convert_to_hr_min_sec(self, time_in_minutes) -> str:
+        # Hr:Min:Sec
+        hours = int(time_in_minutes // 60)
+        minutes = int(time_in_minutes % 60)
+        seconds = int((time_in_minutes - int(time_in_minutes)) * 60)
+        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+
+    def pinecone_upsert(
+        self,
+        transcript: pd.DataFrame,
+        meeting_uuid: str = "",
+        meeting_video_file: bool = False,
+        meeting_title: str = "Unnamed",
+        meeting_summary: str = "",
+    ) -> None:
+        """
+        Upserts the transcript into Pinecone
+        """
+        print("Upserting transcript into Pinecone...")
+        texts = []
+        metadatas = []
+
+        last_conversation_no = self._get_last_conversation_no()
+        last_conversation_no = int(last_conversation_no) 
+
+        embed = self._get_vector_embedder()
+        meeting_members = self._get_meeting_members(transcript)
+        index = self._get_index()
+
+        for _, record in transcript.iterrows():
+            start_time = self._convert_to_hr_min_sec(record["start_time"])
+
+            metadata = {
+                "speaker": record["speaker_label"],
+                "start_time": start_time,
+                "text": record["text"],
+                "meeting_uuid": meeting_uuid,
+            }
+            texts.append(record["text"])
+            metadatas.append(metadata)
+
+            if len(texts) >= self.pinecone_upsert_batch_limit:
+                ids = list(
+                    map(
+                        lambda i: str(i + 1),
+                        range(last_conversation_no, last_conversation_no + len(texts)),
+                    )
+                )
+                last_conversation_no += len(texts)
+                embeds = embed.embed_documents(texts)
+
+                try:
+                    index.upsert(
+                        vectors=zip(ids, embeds, metadatas),
+                        namespace=self.pinecone_namespace,
+                    )
+                except Exception as e:
+                    print("Error upserting into Pinecone: ", e)
+                texts = []
+                metadatas = []
+
+        # Upsert the remaining texts
+        if len(texts) > 0:
+            ids = list(
+                map(
+                    lambda i: str(i + 1),
+                    range(last_conversation_no, last_conversation_no + len(texts)),
+                )
+            )
+            last_conversation_no += len(texts)
+            embeds = embed.embed_documents(texts)
+
+            try:
+                index.upsert(
+                    vectors=zip(ids, embeds, metadatas),
+                    namespace=self.pinecone_namespace,
+                )
+            except Exception as e:
+                print("Error upserting into Pinecone: ", e)
+
+        self._set_new_meeting_json(
+            meeting_uuid,
+            meeting_title,
+            last_conversation_no,
+            meeting_members,
+            meeting_video_file,
+            meeting_summary,
+        )
+
+        print("Upserted transcript into Pinecone")
+
+    def _extract_id_from_response(self, response: list) -> list[int]:
+        if response:
+            return list(int(match["id"]) for match in response["matches"])
+        return []
+
+    def query_pinecone(
+        self, query: str, in_filter: list[str] = [], complete_db_flag: bool = False
+    ) -> list:
+        """
+        Queries Pinecone for the given query, where in_filter is the list of meeting_uuids to filter the query 
+        and if complete_db_flag is True, the entire database is queried
+        """
+        # for using without clustering, complete_db_flag to True
+        try:
+            index = self._get_index()
+            embed = self._get_vector_embedder()
+
+            filter = None if complete_db_flag else {"meeting_uuid": {"$in": in_filter}}
+
+            self.response = index.query(
+                vector=embed.embed_documents([query])[0],
+                namespace=self.pinecone_namespace,
+                top_k=self.pinecone_top_k_results,
+                include_metadata=True,
+                filter=filter,
+            )
+            return self.response
+        except Exception as e:
+            print("Error querying Pinecone: ", e)
+        return []
+
+
+    def query_delta_conversations(self) -> pd.DataFrame:
+        """
+        Queries Pinecone for the given query and returns the delta conversations (conversation window around the query result)
+        """
+        ids = self._extract_id_from_response(self.response)
+        last_conversation_no = self._get_last_conversation_no()
+        index = self._get_index()
+        conversation = {}
+
+        for id in ids:
+            left = (
+                id - self.pinecone_delta_window
+                if id - self.pinecone_delta_window > 0
+                else 1
+            )
+            right = (
+                id + self.pinecone_delta_window
+                if id + self.pinecone_delta_window <= last_conversation_no
+                else last_conversation_no
+            )
+            window = [str(i) for i in range(left, right + 1)]
+            try:
+                # print("Fetch window: ", window)
+                print("Contextual Window Conversation IDs: ", window)
+                fetch_response = index.fetch(
+                    ids=window, namespace=self.pinecone_namespace
+                )
+                conversation[id] = fetch_response
+            except Exception as e:
+                print("Error fetching from Pinecone for id:", id, "Error:", e)
+                continue
+        # print('conversation length: ', len(conversation))
+        return self._parse_fetch_conversations(conversation)
+
+
+    def _parse_fetch_conversations(self, conversation)-> dict:
+        '''
+        Parses the conversation dictionary and returns a grouped_dfs
+        '''
+        data_rows = []
+        for primary_hit_id, primary_hit_data in conversation.items():
+            for _, vector_data in primary_hit_data["vectors"].items():
+                id = vector_data["id"]
+                meeting_uuid = vector_data["metadata"]["meeting_uuid"]
+                speaker = vector_data["metadata"]["speaker"]
+                start_time = vector_data["metadata"]["start_time"]
+                text = vector_data["metadata"]["text"]
+
+                data_rows.append(
+                    (primary_hit_id, id, meeting_uuid, speaker, start_time, text)
+                )
+
+        columns = ["primary_id", "id", "meeting_uuid", "speaker", "start_time", "text"]
+        delta_conversation_df = pd.DataFrame(data_rows, columns=columns)
+        delta_conversation_df = delta_conversation_df.sort_values(by=["id"])
+        delta_conversation_df = delta_conversation_df.drop_duplicates(subset=["id"])
+
+        # creating separate df for rows with same meeting_cluster_id
+        grouped_dfs = {
+            group_name: group.reset_index(drop=True, inplace=False)
+            for group_name, group in delta_conversation_df.groupby("meeting_uuid")
+        }
+        # return delta_conversation_df
+        return grouped_dfs
+
+
+if __name__ == "__main__":
+    pinecone = PineconeServerless()
+    print(pinecone.describe_index_stats())
+
+    for i in range(1, 3):
+        print(i)
+        transcript = pd.read_csv(f"./data/transcriptFiles/healthcare_{i}.csv")
+        transcript.dropna(inplace=True)
+        pinecone.pinecone_upsert(
+            transcript,
+            meeting_uuid=str(uuid.uuid4()),
+            meeting_video_file=False,
+            meeting_title=f"Healthcare Meeting {i}",
+            meeting_summary=f"Healthcare Meeting Summary Meeting {i}",
+        )
+        time.sleep(5)
+    print(pinecone.describe_index_stats())
+
+    query = "I am one of the directors in Wappingers Central School District."
+    response1 = pinecone.query_pinecone(query, "", True)
+    print(response1)

src/utils/resonate_streamlitUtils.py

@@ -0,0 +1,80 @@
+import moviepy.editor as mp
+import json
+from datetime import datetime, timedelta
+from src.aws.resonate_aws_functions import resonate_aws_transcribe
+import os
+
+from src.pinecone.resonate_pinecone_functions import PineconeServerless
+import time
+import uuid
+import pandas as pd
+
+
+def convert_video_to_audio(video_path, audio_path):
+    # Convert video file to audio file
+    audio_clip = mp.VideoFileClip(video_path).audio
+    audio_clip.write_audiofile(audio_path)
+
+
+def transcript_text_editor_minutes_to_hhmmss(minutes):
+    time_delta = timedelta(minutes=minutes)
+    hhmmss_format = str(time_delta)
+    return hhmmss_format
+
+
+def load_json_config(json_file_path="./config/config.json"):
+    # Use a context manager to ensure the file is properly closed after opening
+    with open(json_file_path, "r") as file:
+        # Load the JSON data
+        data = json.load(file)
+    return data
+
+
+def aws_transcribe(file_name):
+
+    json_config = load_json_config()
+    current_timestamp = str.lower(datetime.now().strftime("%Y-%b-%d-%I-%M-%p"))
+
+    json_config["AWS_INPUT_BUCKET"] += f"{str(current_timestamp)}"
+    json_config["AWS_OUTPUT_BUCKET"] += f"{str(current_timestamp)}"
+    json_config["AWS_TRANSCRIBE_JOB_NAME"] += f"{str(current_timestamp)}"
+
+    print(json_config)
+
+    try:
+        rat = resonate_aws_transcribe()
+        df = rat.runner(
+            file_name=file_name,
+            input_bucket=json_config["AWS_INPUT_BUCKET"],
+            output_bucket=json_config["AWS_OUTPUT_BUCKET"],
+            transcribe_job_name=json_config["AWS_TRANSCRIBE_JOB_NAME"],
+            aws_access_key=os.getenv("AWS_ACCESS_KEY"),
+            aws_secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
+            aws_region_name=json_config["AWS_REGION"],
+        )
+
+        return df
+    except Exception as e:
+        return e
+
+
+def pinecone_init_upsert(
+    df_transcript: pd.DataFrame,
+    meeting_title: str,
+    meeting_summary: str,
+    meeting_uuid: str,
+):
+    try:
+
+        pinecone = PineconeServerless()
+        pinecone.pinecone_upsert(
+            df_transcript,
+            # meeting_uuid=NULL,
+            meeting_uuid=meeting_uuid,
+            meeting_video_file=False,
+            meeting_title=meeting_title,
+            meeting_summary=meeting_summary,
+        )
+        time.sleep(5)
+    except Exception as e:
+        print("Error upserting transcript to Pinecone: ", e)