Upload 12 files

ai-sales-call-assistant-457770399a34.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "ai-sales-call-assistant",
+  "private_key_id": "457770399a34b7fd34c166b27b25e0db381d32a8",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCqjFfvqapmJXtt\nG5NXZ8FoyxyCMflUI8EtyGiDjwuFsuHK6sQ6ZoMD/dWObHJH8p4kiiU+OvUSa5gM\nt8zYPnjpgV3FwU1opPL1kGFyip+MZxpbL0aY7rmrROUJKHXULFyjnKiWfMQqlxYk\nFAULWlPfkTM0abAJg6cSMSuZPo2Unb9yGhFdQObBL0Wg4QfulcKGMQGRmOvJsOwf\nCy+tUfZ9dAc0kKCnH5fZu6+/38Mq0Kc8IzJzgJwB+1VWvRfvKdSOI9oVw3nk3Ycm\nCpBMYv/mVybkSaDR1JSM3+7MLRDm53vCucB2HA+0Xui1WbHwbCAsUw+aHORcARLs\nxpRh0OelAgMBAAECggEAI1Tpzsu+cmTnegYRczUae2RAprRFq+mwVpTDGiYjQ/J4\nFnqmZlbgY45NlLDgyAj6PCWma4r5RHSnzlKxjEb885sKWzKdn8U0VC0yEvGm9gZS\nDnvvyzUBn/qo3EnWhzsdggOtZWe5l/0u6BCBrwVqhNFm4z/V6VKt5PXsy1WLLTNe\nROi8E9ezhRGfsn7oYa0uy8UEgddUeEUhLpFoX6WRO13e80hKCGk72tEL2MXAa8lR\nE/LtN9tQl/NlhMGHyB7+OyXkthZxCZaSzVhOV4K31uY4JMPvnKdNBrusjhj1KLGv\njb0QiKuoPFDhqMjIDwFv0xG2AjcCkdjqd5FqaQDdrQKBgQDc9gH6d8iatdW6ipo8\nL3/a93SNGQ9CPBx3+EF7zpbh24dEIaItjUSqFwLBFM84yysB0DU6HPj1MrZ3OtIe\njCjXYHlbn9fRz8gmps54RyoOaEvr9nauOej4MQ4tkn7cDIv2kVvewMRGcEO2DRXJ\nLg9mwxjxMVWSoy+A1P9LhjVqWwKBgQDFl8+9z/9tT0OoFZruWpz+ozKisCoPOp+l\nMz1+rYnB0h4LSY0TBPoqy296WkIDc/WTrHPlnmC5vEgjvT5v3KT3yHd0fIkw9AmM\nF59He6Ihj+FGrRxYO1xadVYdSCIHy4pCGOZLpKInWuZ1sdEQVzw4gYCxcfrMb4mO\nUAuUTy+V/wKBgFiguFRtnWIo00yacZj4eHEs1mwOBCfOEqEwS5vMVorLUitKzlE1\nG7iZuDoYDbI7E8oLaH4hxt4a9ENIraUhFPSmtqbAq4F1tVODjseBy+Wxgdpoplvl\n0INUsdonq4i5454H2fC0I0YZm583CmkCd50BXkzIPAmwOMqVJL13XI+HAoGAf4NB\n0BeLmcoeOjl/GzSkvfspcS3IZr2JSv3vQHHTRZ5IPzZ+8Pg0TSutzEK0+S97Goqe\n3F7BwvsLfuzgfyXf2/ulgynfCxVhl+OiqWnSrmAAnDCY6yObrNCt+wWS2H70wUT6\nUXR0JHuX3/oZlbcGKN0B5QFOPWH5Xjqvzkzvw5cCgYAlsZVJGakTmN6EEjYi/OwM\nUMQfuY6CPLD3kj57sezyW4fHKXwTkQ0y7fmHV4opQmuNbU9o1FBIVvZr03oBgXbm\n60K5qTE6JCKj7mPM9nOGl3327+DPGmIrQus+CsPPi6j8CLu4AXkmOhZ0aR2+Hy4e\nRLzsKUU3oGJ7pa1xFEGwJg==\n-----END PRIVATE KEY-----\n",
+  "client_email": "sales-bot-service@ai-sales-call-assistant.iam.gserviceaccount.com",
+  "client_id": "107478451989301946230",
+  "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/sales-bot-service%40ai-sales-call-assistant.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

app.py

@@ -0,0 +1,295 @@
+import speech_recognition as sr
+from sentiment_analysis import analyze_sentiment
+from product_recommender import ProductRecommender
+from objection_handler import ObjectionHandler
+from google_sheets import fetch_call_data, store_data_in_sheet
+from sentence_transformers import SentenceTransformer
+from env_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\shaik\Downloads\Sales Calls Transcriptions - Sheet2.csv")
+objection_handler = ObjectionHandler(r"C:\Users\shaik\Downloads\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="Sales Call Assistant", layout="wide")
+    st.title("AI Sales Call Assistant")
+
+    st.sidebar.title("Navigation")
+    app_mode = st.sidebar.radio("Choose a mode:", ["Real-Time Call Analysis", "Dashboard"])
+
+    if app_mode == "Real-Time Call Analysis":
+        st.header("Real-Time Sales Call Analysis")
+        if st.button("Start Listening"):
+            real_time_analysis()
+
+    elif app_mode == "Dashboard":
+        st.header("Call Summaries and Sentiment 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': 'blue'
+                        }
+                    )
+                    st.plotly_chart(fig_pie)
+
+                # Bar Chart
+                with col2:
+                    st.subheader("Sentiment Counts")
+                    fig_bar = px.bar(
+                        x=sentiment_counts.index, 
+                        y=sentiment_counts.values, 
+                        title='Number of Calls by Sentiment',
+                        labels={'x': 'Sentiment', 'y': 'Number of Calls'},
+                        color=sentiment_counts.index,
+                        color_discrete_map={
+                            'POSITIVE': 'green', 
+                            'NEGATIVE': 'red', 
+                            'NEUTRAL': 'blue'
+                        }
+                    )
+                    st.plotly_chart(fig_bar)
+
+                # 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[['Call ID', 'Chunk', 'Sentiment', 'Summary Preview', 'Overall Sentiment']])
+
+                # Dropdown to select Call ID
+                unique_call_ids = data[data['Call ID'] != '']['Call ID'].unique()
+                call_id = st.selectbox("Select a Call ID to view details:", unique_call_ids)
+
+                # Display selected Call ID details
+                call_details = data[data['Call ID'] == call_id]
+                if not call_details.empty:
+                    st.subheader("Detailed Call Information")
+                    st.write(f"**Call ID:** {call_id}")
+                    st.write(f"**Overall Sentiment:** {call_details.iloc[0]['Overall Sentiment']}")
+                    
+                    # Expand summary section
+                    st.subheader("Full Call Summary")
+                    st.text_area("Summary:", 
+                                 value=call_details.iloc[0]['Summary'], 
+                                 height=200, 
+                                 disabled=True)
+                    
+                    # Show all chunks for the selected call
+                    st.subheader("Conversation Chunks")
+                    for _, row in call_details.iterrows():
+                        if pd.notna(row['Chunk']):  
+                            st.write(f"**Chunk:** {row['Chunk']}")
+                            st.write(f"**Sentiment:** {row['Sentiment']}")
+                            st.write("---")  # Separator between chunks
+                else:
+                    st.error("No details available for the selected Call ID.")
+        except Exception as e:
+            st.error(f"Error loading dashboard: {e}")
+
+if __name__ == "__main__":
+    run_app()

env_setup.py

@@ -0,0 +1,14 @@
+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"),
+    "PRODUCT_DATA_PATH": os.getenv("PRODUCT_DATA_PATH"),
+    "OBJECTION_DATA_PATH": os.getenv("OBJECTION_DATA_PATH"),
+    "cohere_api_key": os.getenv("cohere_api_key")
+}

google_sheets.py

@@ -0,0 +1,85 @@
+import uuid
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from env_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.")
+    except Exception as e:
+        print(f"Error updating Google Sheets: {e}")
+
+def fetch_call_data(sheet_id, sheet_range="Sheet1!A1:E"):
+    """
+    Fetches data from the specified Google Sheet and returns a pandas DataFrame.
+
+    :param sheet_id: The ID of the Google Sheet to fetch data from.
+    :param sheet_range: The range in A1 notation to fetch data from.
+    :return: pandas DataFrame with the sheet data.
+    """
+    try:
+        # Authenticate and get credentials
+        creds = authenticate_google_account()
+        service = build('sheets', 'v4', credentials=creds)
+        sheet = service.spreadsheets()
+
+        # Fetch the data
+        result = sheet.values().get(
+            spreadsheetId=sheet_id,
+            range=sheet_range
+        ).execute()
+        
+        # Get the rows
+        rows = result.get("values", [])
+        
+        # If rows exist, convert to DataFrame
+        if rows:
+            # Use the first row as column headers
+            headers = rows[0]
+            data = rows[1:]
+            
+            # Create DataFrame
+            df = pd.DataFrame(data, columns=headers)
+            
+            return df
+        else:
+            # Return an empty DataFrame if no data
+            return pd.DataFrame()
+    
+    except Exception as e:
+        print(f"Error fetching data from Google Sheets: {e}")
+        # Return an empty DataFrame in case of error
+        return pd.DataFrame()

main.py

@@ -0,0 +1,117 @@
+import streamlit as st
+import pyaudio
+import json
+from vosk import Model, KaldiRecognizer
+from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
+from sentence_transformers import SentenceTransformer
+import time
+import pandas as pd
+from dotenv import load_dotenv
+import os
+import numpy as np
+
+def cosine_similarity(a, b):
+    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
+
+class SalesAnalysisApp:
+    def __init__(self):
+        model_name = "tabularisai/multilingual-sentiment-analysis"
+        model = AutoModelForSequenceClassification.from_pretrained(model_name)
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.sentiment_analyzer = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
+        
+        vosk_model_path = os.getenv("VOSK_MODEL_PATH")
+        self.vosk_model = Model(vosk_model_path)
+        self.recognizer = KaldiRecognizer(self.vosk_model, 16000)
+        
+        self.audio = pyaudio.PyAudio()
+        self.stream = None
+        
+        self.product_data = pd.read_csv(r"C:\Users\shaik\Downloads\Sales Calls Transcriptions - Sheet2.csv")
+        self.objection_data = pd.read_csv(r"C:\Users\shaik\Downloads\Sales Calls Transcriptions - Sheet3.csv")
+        
+        self.sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
+
+    def get_recommendations(self, text):
+        text_embedding = self.sentence_model.encode([text])
+        product_embeddings = self.sentence_model.encode(self.product_data['Description'].tolist())
+        
+        similarities = [cosine_similarity(text_embedding[0], prod_emb) for prod_emb in product_embeddings]
+        top_indices = np.argsort(similarities)[-5:][::-1]
+        return self.product_data.iloc[top_indices]['Product'].tolist()
+
+    def get_objection_response(self, text):
+        text_embedding = self.sentence_model.encode([text])
+        objection_embeddings = self.sentence_model.encode(self.objection_data['Objection'].tolist())
+        
+        similarities = [cosine_similarity(text_embedding[0], obj_emb) for obj_emb in objection_embeddings]
+        max_similarity = max(similarities)
+        if max_similarity > 0.5:
+            top_idx = np.argmax(similarities)
+            return self.objection_data.iloc[top_idx]['Response']
+        return None
+
+    # Rest of the code remains the same...
+    def analyze_sentiment(self, text):
+        if not text.strip():
+            return "NEUTRAL", 0.0
+        result = self.sentiment_analyzer(text.strip().lower())[0]
+        sentiment_map = {
+            'Very Negative': "NEGATIVE",
+            'Negative': "NEGATIVE",
+            'Neutral': "NEUTRAL",
+            'Positive': "POSITIVE",
+            'Very Positive': "POSITIVE"
+        }
+        return sentiment_map.get(result['label'], "NEUTRAL"), result['score']
+
+    def run_app(self):
+        st.title("Real-time Sales Call Analysis")
+        
+        if st.button("Start Recording"):
+            self.stream = self.audio.open(format=pyaudio.paInt16,
+                                        channels=1,
+                                        rate=16000,
+                                        input=True,
+                                        frames_per_buffer=4000)
+            
+            transcript_placeholder = st.empty()
+            sentiment_placeholder = st.empty()
+            recommendations_placeholder = st.empty()
+            objections_placeholder = st.empty()
+            
+            try:
+                while True:
+                    data = self.stream.read(4000, exception_on_overflow=False)
+                    
+                    if self.recognizer.AcceptWaveform(data):
+                        result = json.loads(self.recognizer.Result())
+                        text = result["text"]
+                        
+                        if text:
+                            transcript_placeholder.write(f"Transcription: {text}")
+                            
+                            sentiment, score = self.analyze_sentiment(text)
+                            sentiment_placeholder.write(f"Sentiment: {sentiment} (Score: {score:.2f})")
+                            
+                            recommendations = self.get_recommendations(text)
+                            if recommendations:
+                                recommendations_placeholder.write("Product Recommendations:")
+                                for rec in recommendations:
+                                    recommendations_placeholder.write(f"- {rec}")
+                            
+                            objection_response = self.get_objection_response(text)
+                            if objection_response:
+                                objections_placeholder.write(f"Suggested Response: {objection_response}")
+                            
+                            time.sleep(0.1)
+                            
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+                if self.stream:
+                    self.stream.stop_stream()
+                    self.stream.close()
+
+if __name__ == "__main__":
+    app = SalesAnalysisApp()
+    app.run_app()

ml_insights.py

@@ -0,0 +1,55 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.linear_model import LinearRegression
+import streamlit as st
+
+def generate_insights(call_data):
+    """
+    Generate ML insights and visualizations from call data
+    """
+    # Convert call data to DataFrame
+    df = pd.DataFrame(call_data)
+    
+    # Sentiment distribution pie chart
+    plt.figure(figsize=(10, 6))
+    sentiment_counts = df['sentiment'].value_counts()
+    plt.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%')
+    plt.title('Sentiment Distribution')
+    st.pyplot(plt)
+    plt.close()
+
+    # Calculate sentiment trend
+    df['sentiment_numeric'] = df['sentiment'].map({'POSITIVE': 1, 'NEGATIVE': -1, 'NEUTRAL': 0})
+    
+    # Simple trend analysis
+    X = np.array(range(len(df))).reshape(-1, 1)
+    y = df['sentiment_numeric'].values
+    
+    model = LinearRegression()
+    model.fit(X, y)
+    
+    # Predict trend
+    trend_score = model.coef_[0]
+    trend_interpretation = (
+        "Improving" if trend_score > 0.1 else 
+        "Declining" if trend_score < -0.1 else 
+        "Stable"
+    )
+    
+    # Summary metrics
+    st.subheader("Call Analysis Summary")
+    st.write(f"Total Calls: {len(df)}")
+    st.write("Sentiment Breakdown:")
+    st.write(sentiment_counts)
+    st.write(f"Sentiment Trend: {trend_interpretation}")
+
+def main():
+    st.title("Sales Call Insights")
+    
+    # Placeholder for loading data mechanism
+    st.write("Insights generation ready.")
+
+if __name__ == "__main__":
+    main()

objection_handler.py

@@ -0,0 +1,40 @@
+import pandas as pd
+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}")
+        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)
+        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

product_recommender.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)
+        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

requirements.txt

@@ -0,0 +1,15 @@
+google-api-python-client==2.98.0
+google-auth-httplib2==0.1.0
+google-auth-oauthlib==0.6.0
+huggingface-hub==0.16.4
+transformers==4.32.0
+torch==2.1.0
+speechrecognition==3.8.1
+pyaudio==0.2.11
+python-dotenv==1.0.0
+vosk==0.3.32  
+pandas==2.1.4
+plotly==5.18.0
+streamlit==1.30.0
+sentence-transformers==2.2.2
+faiss-cpu==1.7.4

sentiment_analysis.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 product_recommender import ProductRecommender
+from objection_handler import load_objections, check_objections  # Ensure check_objections is imported
+from objection_handler import ObjectionHandler
+from env_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\shaik\Downloads\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\shaik\Downloads\Sales Calls Transcriptions - Sheet3.csv")
+    product_recommender = ProductRecommender(r"C:\Users\shaik\Downloads\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\shaik\Downloads\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)

speech_to_text.py

@@ -0,0 +1,76 @@
+from dotenv import load_dotenv
+import os
+from vosk import Model, KaldiRecognizer
+import pyaudio
+import json
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Get the Vosk model path from the environment variable
+vosk_model_path = os.getenv("vosk_model_path")
+
+if not vosk_model_path:
+    print("Error: vosk_model_path is not set in the .env file.")
+    exit()
+
+# Initialize the Vosk model
+try:
+    model = Model(vosk_model_path)
+    print("Vosk model loaded successfully.")
+except Exception as e:
+    print(f"Failed to load Vosk model: {e}")
+    exit()
+
+# Initialize recognizer and audio input
+recognizer = KaldiRecognizer(model, 16000)
+audio = pyaudio.PyAudio()
+
+# Open audio stream
+stream = audio.open(format=pyaudio.paInt16, 
+                    channels=1, 
+                    rate=16000, 
+                    input=True, 
+                    frames_per_buffer=4000)
+stream.start_stream()
+
+print("Say 'start listening' to begin transcription and 'stop listening' to stop.")
+
+# State management
+is_listening = False
+
+try:
+    while True:
+        data = stream.read(4000, exception_on_overflow=False)
+
+        if recognizer.AcceptWaveform(data):
+            result = recognizer.Result()
+            text = json.loads(result)["text"]
+            
+            # Check for commands to start or stop listening
+            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. Say 'start listening' to resume.")
+                continue
+
+            # Transcribe if actively listening
+            if is_listening:
+                print(f"Transcription: {text}")
+        else:
+            # Handle partial results if needed
+            chunk_result = recognizer.PartialResult()
+            chunk_text = json.loads(chunk_result)["partial"]
+
+            # Display partial transcription only if actively listening
+            if is_listening and chunk_text:
+                print(f"chunk: {chunk_text}", end="\r")
+
+except KeyboardInterrupt:
+    print("\nExiting...")
+    stream.stop_stream()
+    stream.close()
+    audio.terminate()

utils.py

@@ -0,0 +1,15 @@
+import os
+from dotenv import load_dotenv
+
+# Function to load environment variables from .env file
+def load_env_variables():
+    # Load environment variables from .env file
+    load_dotenv()
+
+    # Return the loaded environment variables as a dictionary
+    return {
+        'assemblyai_api_key': os.getenv('ASSEMBLYAI_API_KEY'),
+        'huggingface_api_key': os.getenv('HUGGINGFACE_API_KEY'),
+        'google_creds': os.getenv('GOOGLE_CREDS_PATH'),
+        'google_sheet_id': os.getenv('GOOGLE_SHEET_ID')
+    }