Upload 9 files

app.py

@@ -0,0 +1,298 @@
+import speech_recognition as sr
+from sentiment import analyze_sentiment
+from recommendations import ProductRecommender
+from objection_handling import ObjectionHandler
+from sheets import fetch_call_data, store_data_in_sheet
+from sentence_transformers import SentenceTransformer
+from setup import config
+import re
+import uuid
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objs as go
+import streamlit as st 
+
+# Initialize components
+product_recommender = ProductRecommender(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet2.csv")
+objection_handler = ObjectionHandler(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet3.csv")
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+def generate_comprehensive_summary(chunks):
+    """
+    Generate a comprehensive summary from conversation chunks
+    """
+    # Extract full text from chunks
+    full_text = " ".join([chunk[0] for chunk in chunks])
+    
+    # Perform basic analysis
+    total_chunks = len(chunks)
+    sentiments = [chunk[1] for chunk in chunks]
+    
+    # Determine overall conversation context
+    context_keywords = {
+        'product_inquiry': ['dress', 'product', 'price', 'stock'],
+        'pricing': ['cost', 'price', 'budget'],
+        'negotiation': ['installment', 'payment', 'manage']
+    }
+    
+    # Detect conversation themes
+    themes = []
+    for keyword_type, keywords in context_keywords.items():
+        if any(keyword.lower() in full_text.lower() for keyword in keywords):
+            themes.append(keyword_type)
+    
+    # Basic sentiment analysis
+    positive_count = sentiments.count('POSITIVE')
+    negative_count = sentiments.count('NEGATIVE')
+    neutral_count = sentiments.count('NEUTRAL')
+    
+    # Key interaction highlights
+    key_interactions = []
+    for chunk in chunks:
+        if any(keyword.lower() in chunk[0].lower() for keyword in ['price', 'dress', 'stock', 'installment']):
+            key_interactions.append(chunk[0])
+    
+    # Construct summary
+    summary = f"Conversation Summary:\n"
+    
+    # Context and themes
+    if 'product_inquiry' in themes:
+        summary += "• Customer initiated a product inquiry about items.\n"
+    
+    if 'pricing' in themes:
+        summary += "• Price and budget considerations were discussed.\n"
+    
+    if 'negotiation' in themes:
+        summary += "• Customer and seller explored flexible payment options.\n"
+    
+    # Sentiment insights
+    summary += f"\nConversation Sentiment:\n"
+    summary += f"• Positive Interactions: {positive_count}\n"
+    summary += f"• Negative Interactions: {negative_count}\n"
+    summary += f"• Neutral Interactions: {neutral_count}\n"
+    
+    # Key highlights
+    summary += "\nKey Conversation Points:\n"
+    for interaction in key_interactions[:3]:  # Limit to top 3 key points
+        summary += f"• {interaction}\n"
+    
+    # Conversation outcome
+    if positive_count > negative_count:
+        summary += "\nOutcome: Constructive and potentially successful interaction."
+    elif negative_count > positive_count:
+        summary += "\nOutcome: Interaction may require further follow-up."
+    else:
+        summary += "\nOutcome: Neutral interaction with potential for future engagement."
+    
+    return summary
+
+def is_valid_input(text):
+    text = text.strip().lower()
+    if len(text) < 3 or re.match(r'^[a-zA-Z\s]*$', text) is None:
+        return False
+    return True
+
+def is_relevant_sentiment(sentiment_score):
+    return sentiment_score > 0.4
+
+def calculate_overall_sentiment(sentiment_scores):
+    if sentiment_scores:
+        average_sentiment = sum(sentiment_scores) / len(sentiment_scores)
+        overall_sentiment = (
+            "POSITIVE" if average_sentiment > 0 else
+            "NEGATIVE" if average_sentiment < 0 else
+            "NEUTRAL"
+        )
+    else:
+        overall_sentiment = "NEUTRAL"
+    return overall_sentiment
+
+def real_time_analysis():
+    recognizer = sr.Recognizer()
+    mic = sr.Microphone()
+
+    st.info("Say 'stop' to end the process.")
+
+    sentiment_scores = []
+    transcribed_chunks = []
+    total_text = ""
+
+    try:
+        while True:
+            with mic as source:
+                st.write("Listening...")
+                recognizer.adjust_for_ambient_noise(source)
+                audio = recognizer.listen(source)
+
+            try:
+                st.write("Recognizing...")
+                text = recognizer.recognize_google(audio)
+                st.write(f"*Recognized Text:* {text}")
+
+                if 'stop' in text.lower():
+                    st.write("Stopping real-time analysis...")
+                    break
+
+                # Append to the total conversation
+                total_text += text + " "
+                sentiment, score = analyze_sentiment(text)
+                sentiment_scores.append(score)
+                
+                # Handle objection
+                objection_response = handle_objection(text)
+
+                # Get product recommendation
+                recommendations = []
+                if is_valid_input(text) and is_relevant_sentiment(score):
+                    query_embedding = model.encode([text])
+                    distances, indices = product_recommender.index.search(query_embedding, 1)
+
+                    if distances[0][0] < 1.5:  # Similarity threshold
+                        recommendations = product_recommender.get_recommendations(text)
+
+                transcribed_chunks.append((text, sentiment, score))
+
+                st.write(f"*Sentiment:* {sentiment} (Score: {score})")
+                st.write(f"*Objection Response:* {objection_response}")
+                
+                if recommendations:
+                    st.write("*Product Recommendations:*")
+                    for rec in recommendations:
+                        st.write(rec)
+
+            except sr.UnknownValueError:
+                st.error("Speech Recognition could not understand the audio.")
+            except sr.RequestError as e:
+                st.error(f"Error with the Speech Recognition service: {e}")
+            except Exception as e:
+                st.error(f"Error during processing: {e}")
+
+        # After conversation ends, calculate and display overall sentiment and summary
+        overall_sentiment = calculate_overall_sentiment(sentiment_scores)
+        call_summary = generate_comprehensive_summary(transcribed_chunks)
+        
+        st.subheader("Conversation Summary:")
+        st.write(total_text.strip())
+        st.subheader("Overall Sentiment:")
+        st.write(overall_sentiment)
+
+        # Store data in Google Sheets
+        store_data_in_sheet(
+            config["google_sheet_id"], 
+            transcribed_chunks, 
+            call_summary, 
+            overall_sentiment
+        )
+        st.success("Conversation data stored successfully in Google Sheets!")
+
+    except Exception as e:
+        st.error(f"Error in real-time analysis: {e}")
+
+def handle_objection(text):
+    query_embedding = model.encode([text])
+    distances, indices = objection_handler.index.search(query_embedding, 1)
+    if distances[0][0] < 1.5:  # Adjust similarity threshold as needed
+        responses = objection_handler.handle_objection(text)
+        return "\n".join(responses) if responses else "No objection response found."
+    return "No objection response found."
+
+# (Previous imports remain the same)
+
+def run_app():
+    st.set_page_config(page_title="Vocalytics", layout="wide")
+    st.title("AI Sales Call Assistant")
+    
+    st.sidebar.title("Navigation")
+    app_mode = st.sidebar.radio("Menu", ["Home","Real-Time Recommendations", "Analysis", "Full Call Summary"])
+
+    if app_mode == "Home":
+     st.title("Welcome to the AI Sales Assistant Dashboard!")
+     st.markdown("""
+        ### Features:
+        - Real-Time Transcription: Live transcription with sentiment analysis.
+        - Product Recommendations: Relevant suggestions based on customer conversations.
+        - Objection Handling: Automatic detection and response to objections.
+        - Data Summary: Historical insights stored in Google Sheets.
+        - Analytics: Visualize trends and sentiment distribution.
+    """)
+
+    elif app_mode == "Real-Time Recommendations":
+        st.header("Real-Time Recommendations ")
+        if st.button("Start Listening"):
+            real_time_analysis()
+
+    elif app_mode == "Analysis":
+        st.header("Call Summary and Analysis")
+        try:
+            data = fetch_call_data(config["google_sheet_id"])
+            if data.empty:
+                st.warning("No data available in the Google Sheet.")
+            else:
+                # Sentiment Visualizations
+                sentiment_counts = data['Sentiment'].value_counts()
+                
+                # Pie Chart
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.subheader("Sentiment Distribution")
+                    fig_pie = px.pie(
+                        values=sentiment_counts.values, 
+                        names=sentiment_counts.index, 
+                        title='Call Sentiment Breakdown',
+                        color_discrete_map={
+                            'POSITIVE': 'green', 
+                            'NEGATIVE': 'red', 
+                            'NEUTRAL': 'pink'
+                        }
+                    )
+                    st.plotly_chart(fig_pie)
+
+                # Line Chart for Sentiment Over Time
+                with col2:
+                    st.subheader("Sentiment Over Time")
+                    if 'Sentiment' in data.columns:
+                        data['Index'] = range(1, len(data) + 1)  # Generate indices as time proxy
+                        fig_line = px.line(
+                            data, 
+                            x='Index', 
+                            y='Sentiment', 
+                            title='Sentiment Trend During Calls',
+                            markers=True,
+                            labels={'Index': 'Call Progress (Sequential)', 'Sentiment': 'Sentiment'}
+                        )
+                        st.plotly_chart(fig_line)
+                    else:
+                        st.warning("Sentiment data is not available for trend visualization.")
+
+                # Existing Call Details Section
+                st.subheader("All Calls")
+                display_data = data.copy()
+                display_data['Summary Preview'] = display_data['Summary'].str[:100] + '...'
+                st.dataframe(display_data[['Chunk', 'Sentiment', 'Summary Preview', 'Overall Sentiment']])
+
+        except Exception as e:
+            st.error(f"Error loading dashboard: {e}")
+
+    elif app_mode == "Full Call Summary":
+        st.header("Full Call Summary")
+        try:
+            data = fetch_call_data(config["google_sheet_id"])
+            if data.empty:
+                st.warning("No data available in the Google Sheet.")
+            else:
+                data = data.dropna(subset=['Chunk', 'Summary'])
+
+                for index, row in data.iterrows():
+                    st.text_area(
+                        label=f"Call Summary {index+1}", 
+                        value=row['Summary'], 
+                        height=200, 
+                        key=f"summary_{index}"
+                    )
+        except Exception as e:
+            st.error(f"Error loading full call summary: {e}")
+
+if __name__ == "__main__":
+    run_app()

credentials.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "teak-citadel-438407-i8",
+  "private_key_id": "fe971d8de6089e8c54f1c853d4485602d5f2c642",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQChc0kgGN1xbuf9\niQ7q8175856U+lkwosOuTLsnzzHnNwJmgxwMUU0OTJCWtNystcVXdwZng21/Gl9E\nJIYbrgeW7WURwz0mCtYvfRFzILrGkOqOKBgAoRbKzesAm7x22TlgIXChPY6sdpFM\nVeiaeXEWwB3CLgoo0C24wQbkLvGhEgoOISaXko90wnm4SJUlPBTK4nSeaw6/Kljz\nFvidvspCfwOz/P3Cs2sPrVQzIZW96Kz4GStMApCentFAfPFU5rKc8r/Nn6cdepTZ\nGwEFM41thmvJo+sENme0Lmu4GLX1DlaZmgBe8df8L0NgknDdAZ4wULXg5U2Higmb\ndVlQVCxBAgMBAAECggEAEMKqlzntly6Hx+K4GTz9oZ4gWt/obWugO9J8ZWQVjqa/\nyYuX2FGCWdcp9XM+K3HNVEincgyLS/QdarIN+AanhAwN/3uQuAfM924Y5yZBLYby\nyqIv57TRbGlXGZ+RP5dKZQfjrOF6k73VVKLgfFTaIB3+mN91r4n5DSKAyCR1ch6G\neBom4Q+5571Z/eYCRUZeMf0fVjw/eGRenMK01d1MQYt59G+PZLm0ZmBAOZmDh6yT\nkaCgpZlQnK6DEnhSHnPTWn3V8D1BUHF30/qypBER2GY9NToRFQ3mk5/BZ8b8JQsU\nOyyzFokSnhIKcYiBwwTXOjeDjlsFu4cBw8/0cx/mKQKBgQDa7+gvydpFf7XRTT+P\nLFoBD0cr2XX+xJ5GbQKhdPlgtZZ15YSGW5ogElRRRlXhewCbkCDGWjNBfqjfjdCe\nVQeF2gqRDyg47OkhK+yKgfk52g++BzuupNgMIsxpSehLHQmuqPVVQFDuTiCQc79s\nZ/h+K6SmtKhb2cfo9te8OOioZQKBgQC8yBHBuMHdzDa3iPfSNGLXFReTOJpQxLBr\nqKqHHPN2zSFQuKVc2Hx0vAoG8B3lny82ewV1qVvvRLfi8tUXKUOquhhPoLbs1knp\nUkp0E18hMZc90XxMb1xqORO0hWQG1A8RjSiBiD5Sj8x+Ev/bx9mvpBdwPQReFQ5e\neN1+35rgrQKBgQCwuJ3OlTxehOuZ+qSnSMGNwWtNdcbM0qB/cFaDRQxWh7zfhVgn\nq6EI6kKtJ/0CeGrRJtGNyhk9cKOXb71JUJE19f45gOaSrIixgeb5Fli53c5/MQ93\ntQ+/HAerpUCgANxj43XETpoFAYM/lm6ZboMiNNA+z+xl17CJ11XkVHtYEQKBgD8B\ngzOlp0aQbr6ovxVwGIDycDDZll9Ylg0IeQmpNvSyl+jqB37KXhdT3wDbyQ6nJ0nG\nm1be1GkyBTGAnHAjfIsRmyWQXR0ElByEM4c0I+7fLzwZm6OjEzP8osAAORcyVWkl\nNJyuzSYfCkAVtUE0HUpKuOvj4X5JBsevDTXYCUftAoGBALvQglLh1Bt7gXGheOMO\ncJQ794nfHMTgOl5Zag/hgDxuSc5sLzJ49bfHg5EkMSbZlEBfHrX9PPBYKHucbZQJ\nWO9ljQCN1cpoyyoyTPzldqkahjpiLBx13+VfqXvKE7jxuU4Aj8PPkf/G7eCVkxDh\n9+X9F5KX0FBt672aGr2C/C3O\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "111664813751492591578",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/akshaya%40teak-citadel-438407-i8.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

main.py

@@ -0,0 +1,58 @@
+from sentiment import transcribe_with_chunks
+import streamlit as st
+from sheets import store_data_in_sheet
+from setup import config
+from recommendations import ProductRecommender
+from objection_handling import load_objections, ObjectionHandler
+
+def main():
+    # Load objections and products
+    product_recommender = ProductRecommender(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet2.csv")
+    objection_handler = ObjectionHandler(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet3.csv")
+
+    # Load objections at the start of the script
+    objections_file_path = r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet3.csv"
+    objections_dict = load_objections(objections_file_path)
+
+    # Call the transcription function which now includes objection handling
+    transcribed_chunks = transcribe_with_chunks(objections_dict)
+
+    total_text = ""
+    sentiment_scores = []
+
+    for chunk, sentiment, score in transcribed_chunks:
+        if chunk.strip():  
+            total_text += chunk + " "  # Accumulate the conversation text
+            sentiment_scores.append(score if sentiment == "POSITIVE" else -score)
+
+            # Check for product recommendations
+            recommendations = product_recommender.get_recommendations(chunk)
+            if recommendations:
+                print(f"Recommendations for chunk: '{chunk}'")
+                st.write(f"Recommendations for chunk: '{chunk}'")
+                for idx, rec in enumerate(recommendations, 1):
+                    print(f"{idx}. {rec}")
+                    st.write(f"{idx}. {rec}")
+
+            # Check for objections
+            objection_responses = objection_handler.handle_objection(chunk)
+            if objection_responses:
+                for response in objection_responses:
+                    print(f"Objection Response: {response}")
+                    st.write(f"Objection Response: {response}")
+
+
+    # Determine overall sentiment
+    overall_sentiment = "POSITIVE" if sum(sentiment_scores) > 0 else "NEGATIVE"
+    print(f"Overall Sentiment: {overall_sentiment}")
+    st.write(f"Overall Sentiment: {overall_sentiment}")
+
+    # Generate a summary of the conversation
+    print(f"Conversation Summary: {total_text.strip()}")
+    st.write(f"Conversation Summary: {total_text.strip()}")
+
+    # Store data in Google Sheets
+    store_data_in_sheet(config["google_sheet_id"], transcribed_chunks, total_text.strip(), overall_sentiment)
+
+if __name__ == "__main__":
+    main()

objection_handling.py

@@ -0,0 +1,42 @@
+import pandas as pd
+import streamlit as st
+from sentence_transformers import SentenceTransformer
+import faiss
+
+def load_objections(file_path):
+    """Load objections from a CSV file into a dictionary."""
+    try:
+        objections_df = pd.read_csv(file_path)
+        objections_dict = {}
+        for index, row in objections_df.iterrows():
+            objections_dict[row['Customer Objection']] = row['Salesperson Response']
+        return objections_dict
+    except Exception as e:
+        print(f"Error loading objections: {e}")
+        st.write(f"Error loading objections: {e}")
+        return {}
+
+def check_objections(text, objections_dict):
+    """Check for objections in the given text and return responses."""
+    responses = []
+    for objection, response in objections_dict.items():
+        if objection.lower() in text.lower():
+            responses.append(response)
+    return responses
+
+class ObjectionHandler:
+    def __init__(self, objection_data_path):
+        self.data = pd.read_csv(objection_data_path,encoding='latin1')
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.embeddings = self.model.encode(self.data['Customer Objection'].tolist())
+        self.index = faiss.IndexFlatL2(self.embeddings.shape[1])
+        self.index.add(self.embeddings)
+
+    def handle_objection(self, query, top_n=1):
+        """Handle objections using embeddings."""
+        query_embedding = self.model.encode([query])
+        distances, indices = self.index.search(query_embedding, top_n)
+        responses = []
+        for i in indices[0]:
+            responses.append(self.data.iloc[i]['Salesperson Response'])
+        return responses

recommendations.py

@@ -0,0 +1,19 @@
+import pandas as pd
+from sentence_transformers import SentenceTransformer
+import faiss
+
+class ProductRecommender:
+    def __init__(self, product_data_path):
+        self.data = pd.read_csv(product_data_path,encoding='latin1')
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.embeddings = self.model.encode(self.data['product_description'].tolist())
+        self.index = faiss.IndexFlatL2(self.embeddings.shape[1])
+        self.index.add(self.embeddings)
+
+    def get_recommendations(self, query, top_n=5):
+        query_embedding = self.model.encode([query])
+        distances, indices = self.index.search(query_embedding, top_n)
+        recommendations = []
+        for i in indices[0]:
+            recommendations.append(self.data.iloc[i]['product_title'] + ": " + self.data.iloc[i]['product_description'])
+        return recommendations

sentiment.py

@@ -0,0 +1,177 @@
+import os
+import json
+import time
+import pyaudio
+from vosk import Model, KaldiRecognizer
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+from huggingface_hub import login
+from recommendations import ProductRecommender
+from objection_handling import load_objections, check_objections  # Ensure check_objections is imported
+from objection_handling import ObjectionHandler
+from setup import config
+from sentence_transformers import SentenceTransformer
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Initialize the ProductRecommender
+product_recommender = ProductRecommender(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet2.csv")
+
+# Hugging Face API setup
+huggingface_api_key = config["huggingface_api_key"]
+login(token=huggingface_api_key)
+
+# Sentiment Analysis Model
+model_name = "tabularisai/multilingual-sentiment-analysis"
+model = AutoModelForSequenceClassification.from_pretrained(model_name)
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+sentiment_analyzer = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
+
+# Vosk Speech Recognition Model
+vosk_model_path = config["vosk_model_path"]
+
+if not vosk_model_path:
+    raise ValueError("Error: vosk_model_path is not set in the .env file.")
+
+try:
+    vosk_model = Model(vosk_model_path)
+    print("Vosk model loaded successfully.")
+except Exception as e:
+    raise ValueError(f"Failed to load Vosk model: {e}")
+
+recognizer = KaldiRecognizer(vosk_model, 16000)
+audio = pyaudio.PyAudio()
+
+stream = audio.open(format=pyaudio.paInt16,
+                    channels=1,
+                    rate=16000,
+                    input=True,
+                    frames_per_buffer=4000)
+stream.start_stream()
+
+# Function to analyze sentiment
+def preprocess_text(text):
+    """Preprocess text for better sentiment analysis."""
+    # Strip whitespace and convert to lowercase
+    processed = text.strip().lower()
+    return processed
+
+def preprocess_text(text):
+    """Preprocess text for better sentiment analysis."""
+    return text.strip().lower()
+
+def analyze_sentiment(text):
+    """Analyze sentiment of the text using Hugging Face model."""
+    try:
+        if not text.strip():
+            return "NEUTRAL", 0.0
+        
+        processed_text = preprocess_text(text)
+        result = sentiment_analyzer(processed_text)[0]
+        
+        print(f"Sentiment Analysis Result: {result}")
+        
+        # Map raw labels to sentiments
+        sentiment_map = {
+            'Very Negative': "NEGATIVE",
+            'Negative': "NEGATIVE",
+            'Neutral': "NEUTRAL",
+            'Positive': "POSITIVE",
+            'Very Positive': "POSITIVE"
+        }
+        
+        sentiment = sentiment_map.get(result['label'], "NEUTRAL")
+        return sentiment, result['score']
+        
+    except Exception as e:
+        print(f"Error in sentiment analysis: {e}")
+        return "NEUTRAL", 0.5
+
+def transcribe_with_chunks(objections_dict):
+    """Perform real-time transcription with sentiment analysis."""
+    print("Say 'start listening' to begin transcription. Say 'stop listening' to stop.")
+    is_listening = False
+    chunks = []
+    current_chunk = []
+    chunk_start_time = time.time()
+
+    # Initialize handlers with semantic search capabilities
+    objection_handler = ObjectionHandler(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet3.csv")
+    product_recommender = ProductRecommender(r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet2.csv")
+
+    # Load the embeddings model once
+    model = SentenceTransformer('all-MiniLM-L6-v2')
+
+    try:
+        while True:
+            data = stream.read(4000, exception_on_overflow=False)
+
+            if recognizer.AcceptWaveform(data):
+                result = recognizer.Result()
+                text = json.loads(result)["text"]
+
+                if "start listening" in text.lower():
+                    is_listening = True
+                    print("Listening started. Speak into the microphone.")
+                    continue
+                elif "stop listening" in text.lower():
+                    is_listening = False
+                    print("Listening stopped.")
+                    if current_chunk:
+                        chunk_text = " ".join(current_chunk)
+                        sentiment, score = analyze_sentiment(chunk_text)
+                        chunks.append((chunk_text, sentiment, score))
+                        current_chunk = []
+                    continue
+
+                if is_listening and text.strip():
+                    print(f"Transcription: {text}")
+                    current_chunk.append(text)
+
+                    if time.time() - chunk_start_time > 3:
+                        if current_chunk:
+                            chunk_text = " ".join(current_chunk)
+                            
+                            # Always process sentiment
+                            sentiment, score = analyze_sentiment(chunk_text)
+                            chunks.append((chunk_text, sentiment, score))
+
+                            # Get objection responses and check similarity score
+                            query_embedding = model.encode([chunk_text])
+                            distances, indices = objection_handler.index.search(query_embedding, 1)
+                            
+                            # If similarity is high enough, show objection response
+                            if distances[0][0] < 1.5:  # Threshold for similarity
+                                responses = objection_handler.handle_objection(chunk_text)
+                                if responses:
+                                    print("\nSuggested Response:")
+                                    for response in responses:
+                                        print(f"→ {response}")
+                            
+                            # Get product recommendations and check similarity score
+                            distances, indices = product_recommender.index.search(query_embedding, 1)
+                            
+                            # If similarity is high enough, show recommendations
+                            if distances[0][0] < 1.5:  # Threshold for similarity
+                                recommendations = product_recommender.get_recommendations(chunk_text)
+                                if recommendations:
+                                    print(f"\nRecommendations for this response:")
+                                    for idx, rec in enumerate(recommendations, 1):
+                                        print(f"{idx}. {rec}")
+                            
+                            print("\n")
+                            current_chunk = []
+                            chunk_start_time = time.time()
+
+    except KeyboardInterrupt:
+        print("\nExiting...")
+        stream.stop_stream()
+
+    return chunks
+
+if __name__ == "__main__":
+    objections_file_path = r"C:\Users\Gowri Shankar\Downloads\AI-Sales-Call-Assistant--main\Sales_Calls_Transcriptions_Sheet3.csv"
+    objections_dict = load_objections(objections_file_path)
+    transcribed_chunks = transcribe_with_chunks(objections_dict)
+    print("Final transcriptions and sentiments:", transcribed_chunks)

setup.py

@@ -0,0 +1,13 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+config = {
+    "google_creds": os.getenv("google_creds"),
+    "huggingface_api_key": os.getenv("huggingface_api_key"),
+    "google_sheet_id": os.getenv("google_sheet_id"), 
+    "vosk_model_path": os.getenv("vosk_model_path"),
+    "objections_file_path" : os.getenv("objections_file_path"),
+    "product_data_path" : os.getenv("product_data_path")
+}

sheets.py

@@ -0,0 +1,77 @@
+import uuid
+import streamlit as st
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from setup import config
+import pandas as pd
+
+SCOPES = ['https://www.googleapis.com/auth/spreadsheets']
+
+def authenticate_google_account():
+    service_account_file = config["google_creds"]
+    if not service_account_file:
+        raise ValueError("Service account credentials path is missing in env_setup.py.")
+    return service_account.Credentials.from_service_account_file(service_account_file, scopes=SCOPES)
+
+def store_data_in_sheet(sheet_id, chunks, summary, overall_sentiment):
+    creds = authenticate_google_account()
+    service = build('sheets', 'v4', credentials=creds)
+    sheet = service.spreadsheets()
+
+    call_id = str(uuid.uuid4())
+    print(f"Call ID: {call_id}")
+
+    values = []
+    if chunks:
+        first_chunk, first_sentiment, _ = chunks[0]
+        values.append([call_id, first_chunk, first_sentiment, summary, overall_sentiment])
+    for chunk, sentiment, _ in chunks[1:]:
+        values.append(["", chunk, sentiment, "", ""])
+
+    header = ["Call ID", "Chunk", "Sentiment", "Summary", "Overall Sentiment"]
+    all_values = [header] + values
+
+    body = {'values': all_values}
+    try:
+        result = sheet.values().append(
+            spreadsheetId=sheet_id,
+            range="Sheet1!A1",
+            valueInputOption="RAW",
+            body=body
+        ).execute()
+        print(f"{result.get('updates').get('updatedCells')} cells updated in Google Sheets.")
+        st.write(f"{result.get('updates').get('updatedCells')} cells updated in Google Sheets.")
+    except Exception as e:
+        print(f"Error updating Google Sheets: {e}")
+        st.write(f"Error updating Google Sheets: {e}")
+
+def fetch_call_data(sheet_id, range_name="Sheet1!A1:E"):
+    """
+    Fetch previously saved call data from Google Sheets and return it as a pandas DataFrame.
+    :param sheet_id: ID of the Google Sheet.
+    :param range_name: The range to fetch data from.
+    :return: pandas DataFrame containing the call data.
+    """
+    creds = authenticate_google_account()
+    service = build('sheets', 'v4', credentials=creds)
+    sheet = service.spreadsheets()
+
+    try:
+        result = sheet.values().get(spreadsheetId=sheet_id, range=range_name).execute()
+        rows = result.get('values', [])
+        if rows:
+            # Convert rows to a pandas DataFrame
+            header = rows[0]
+            data = rows[1:]  # Skip the header row
+            df = pd.DataFrame(data, columns=header)
+            print(f"Fetched {len(df)} rows of data from Google Sheets.")
+            st.write(f"Fetched {len(df)} rows of data from Google Sheets.")
+            return df
+        else:
+            print("No data found in the sheet.")
+            st.write("No data found in the sheet.")
+            return pd.DataFrame()  # Return an empty DataFrame if no data
+    except Exception as e:
+        print(f"Error fetching data from Google Sheets: {e}")
+        st.write(f"Error fetching data from Google Sheets: {e}")
+        return pd.DataFrame()  # Return an empty DataFrame on error