Bluetick's Sales call Evaluator

More from Author
Akash Kumar

Engineering Lead

6 min read


In the fast-paced world of sales, every conversation is a potential turning point. Sales executives spend hours analyzing sales calls, extracting insights, and summarizing their content to improve their strategies. Manual call evaluation is both time-consuming and subject to human error, making it a prime candidate for automation through artificial intelligence. In this blog, we'll explore the need for AI in sales call evaluation and how technologies like OpenAI Whisper, Pyannote-Audio, and Pretrained Speaker Embeddings, such as SpeechBrain/spkrec-ecapa-voxceleb, are transforming the sales landscape.

Source code


Sales Call Evaluation

*Kindly be aware that this application is currently running on a CPU server for demonstration purposes. Processing times may extend to a minute or two.

** To utilize preloaded audio files, simply choose from the available examples.

The Need for AI in Sales Call Evaluation

Sales call evaluation is a critical part of a sales team's success. It helps identify what went right and what could be improved, ultimately leading to better sales strategies and more successful interactions with customers. However, manually listening to and summarizing sales calls is a time-consuming process that can be significantly optimized by leveraging generative AI tools.

Consider a scenario where a sales executive spends an average of 10 minutes manually listening to a sales call and writing a summary of the key points. In a busy workday, this can add up to hours of valuable time that could be better utilized for client interactions, strategizing, and other essential tasks. This is where AI-driven tools like the Bluetick Sales Call Evaluator come into play, streamlining the process and making it more efficient.

Key Components used:

1. OpenAI Whisper

OpenAI's Whisper is a state-of-the-art automatic speech recognition (ASR) system that has opened up new horizons in the field of natural language processing. Whisper excels at transcribing spoken language into written text, making it a valuable asset for sales call evaluation. By transcribing sales calls accurately and efficiently, Whisper lays the foundation for more advanced AI-driven analysis.

Sales teams can use Whisper to automatically generate text transcripts of sales calls, enabling them to quickly search for specific keywords or phrases, identify important moments, and gain a better understanding of the conversation's context. This not only saves time but also ensures that no crucial details are missed.

2. Pyannote-Audio for Speaker Diarization

Pyannote-Audio is an open-source toolkit designed for the analysis of audio data. One of its standout features is speaker diarization, a process that divides a conversation into segments, each associated with a specific speaker. In sales call evaluation, this technology allows sales teams to identify who said what during a call, which is crucial for understanding the dynamics of the conversation.

Speaker diarization provided by Pyannote-Audio is a game-changer for sales executives. It allows them to attribute specific statements to either the salesperson or the customer, aiding in the identification of effective communication strategies, clarifying misunderstandings, and enhancing customer relationships.

3. Pretrained Speaker Embeddings - SpeechBrain/spkrec-ecapa-voxceleb

Pretrained speaker embeddings, such as those provided by SpeechBrain/spkrec-ecapa-voxceleb, are the icing on the cake when it comes to sales call evaluation. These embeddings are trained on vast amounts of data, allowing the AI model to understand and recognize distinct speaker characteristics.

Sales teams can use pretrained speaker embeddings to identify speakers, track customer interactions over time, and assess the effectiveness of different sales representatives. This insight can lead to more personalized sales strategies, better-targeted customer engagement, and ultimately, higher conversion rates.

Let's dive right into the coding

Install all the dependencies

 pip install git+ -q
 pip install -q git+
 pip install --quiet openai
 pip install textstat -q

Download and load the whisper model

 from whisper import _download, _MODELS

 _download(_MODELS["medium"], "/models/", False)
 100%|██████████████████████████████████████| 1.42G/1.42G [00:13<00:00,
 113MiB/s] '/models/                           
 import whisper
 model = whisper.load_model('/models/')                             

Convert the mp3 audio to .wav

To use this audio click here

 import wave
 import subprocess

 audio = "/content/customer_support.mp3"
 if audio[-3:] != 'wav':
     audio_file_name = audio.split("/")[-1]
     audio_file_name = audio_file_name.split(".")[0] + ".wav"['ffmpeg', '-i', audio, audio_file_name, '-y'])
     path = audio_file_name                                

Transcribe the audio

 result = model.transcribe(path)
 segments = result["segments"]


[{'id': 0, 'seek': 0, 'start': 0.0, 'end': 5.48, 'text': " Thank you for calling Martha's Flowers Towne SST. Hello I'd like to order flowers"},

{'id': 1, 'seek': 0, 'start': 5.48, 'end': 9.040000000000001, 'text': " and I think you have what I'm looking for. I'd be happy to take care of your"} …

Load the embedding model and perform diarization

 import contextlib

 with contextlib.closing(,'r')) as f:
     frames = f.getnframes()
     rate = f.getframerate()
     duration = frames / float(rate)
 from import 
 import torch

 embedding_model = PretrainedSpeakerEmbedding(
 from import Audio
 from pyannote.core import Segment
 import numpy as np

 audio = Audio()

 def segment_embedding(segment):
     start = segment["start"]
     # Whisper overshoots the end timestamp in the last segment
     end = min(duration, segment["end"])
     clip = Segment(start, end)
     waveform, sample_rate = audio.crop(path, clip)
     waveform = waveform.mean(dim=0, keepdim=True)
     return embedding_model(waveform.unsqueeze(0))

 embeddings = np.zeros(shape=(len(segments), 192))
 for i, segment in enumerate(segments):
     embeddings[i] = segment_embedding(segment)

 embeddings = np.nan_to_num(embeddings)                                

Perform diarization

 from sklearn.cluster import AgglomerativeClustering

 num_speakers = 2  # Set the number of speakers manually

 clustering = AgglomerativeClustering(num_speakers).fit(embeddings)
 labels = clustering.labels_
 for i in range(len(segments)):
    segments[i]["speaker"] = 'SPEAKER '+str(labels[i]+1)                            
 import datetime

 def time(secs):
     return datetime.timedelta(seconds=round(secs))

 conversation = ""

 for (i, segment) in enumerate(segments):
     if i == 0 or segments[i - 1]["speaker"] != segment["speaker"]:
         conversation += "\n" + segment["speaker"] + ' ' + 
 str(time(segment["start"])) + '\n'
     conversation += segment["text"][1:] + ' '

  • SPEAKER 1 0:00:00 Thank you for calling Martha's Flowers Towne SST. Hello I'd like to order flowers
  • SPEAKER 2 0:00:05 and I think you have what I'm looking for. I'd be happy to take care of your
  • SPEAKER 1 0:00:09 order may have your name please. Randall Thomas. Randall Thomas can you spell that for me?
  • SPEAKER 2 0:00:14 Randall R-A-N-B-A-L-L Thomas T-H-O-M-A-S.
    .. .

Perform Analysis with AI

Perform Sentiment Analysis

 import nltk
 from nltk.sentiment.vader import SentimentIntensityAnalyzer'vader_lexicon')

 # Perform sentiment analysis
 sid = SentimentIntensityAnalyzer()
 sentiment_scores = sid.polarity_scores(conversation)

 print(f"Sentiment Analysis:\nPositive: {sentiment_scores['pos']} | 
 Negative: {sentiment_scores['neg']} | Neutral: 
  • Sentiment Analysis: Positive: 0.183 | Negative: 0.037 | Neutral: 0.78

Calculate the Flesch-Kincaid readability score

 import textstat

 # Calculate the Flesch-Kincaid readability score
 readability_score = textstat.flesch_reading_ease(conversation)

 print(f"Readability Score(Flesch-Kincaid):{readability_score}\n\n")                     
  • Readability Score (Flesch-Kincaid): 88.33

Generate call summary

 import openai

 openai.api_key = ""

         "role": "system",
         "content": """
         You will be provided with a conversation. Your task is to give 
 a summary and mention all the main details in bullet points.
         Replace speaker 1 and speaker 2 with sales excutive or comapny 
 name and customer name if available.
         "role": "user",
         "content": conversation

 response = openai.ChatCompletion.create(
  • Customer wants to order flowers from Martha's Flowers Towne SST
  • Customer's name is Randall Thomas
  • Customer's phone number is 409-866-5088
  • Customer's email address is
  • Customer's shipping address is 6800 Gladys Avenue, Beaumont Texas, zip code 77706
  • Customer wants to purchase one dozen long stem red roses - Total amount of the order is $40
  • Customer wants the roses to be delivered within 24 hours - Customer doesn't need any further assistance
  • Customer thanks Martha's Flowers and ends the call


The integration of generative AI technologies like OpenAI Whisper, Pyannote-Audio, and Pretrained Speaker Embeddings is revolutionizing the way sales calls are evaluated. By automating the transcription, diarization, and speaker recognition processes, these tools save sales executives valuable time and provide deeper insights into the dynamics of their sales calls. In a highly competitive sales environment, where every interaction counts, embracing AI-driven solutions can be a game-changer. As technology continues to advance, we can expect even more innovative AI solutions to shape the future of sales call evaluation and, ultimately, sales success.

- Making Every Conversation Count.

Back To Blogs

contact us