Introduction
By no means would have the inventor of e-mail –Ray Tomlinson– considered how far this piece of tech would attain sooner or later. Right now, e-mail is the prime pillar of company {and professional} communications and is utilized in innumerable aspects of the working world. And this has propelled the creation of an entire set of instruments and plugins to optimise your e-mail inbox! With the arrival of generative AI, the newest speak on the town is concerning the widespread use of AI Brokers to optimise emails. On this weblog, I’ll clarify the craft of automating e-mail sorting and labelling by constructing brokers utilizing crewAI.
Overview
- Discover ways to give your functions entry to your Gmail utilizing Google Cloud Console’s OAuth 2.0
- Perceive the code and construct an agent that makes use of an LLM to learn and categorise mails into pre-defined classes.
- Discover ways to automate the method of e-mail sorting and labelling utilizing crewAI by merely operating a Python script.
Understanding the Context
In case you are not dwelling underneath a rock and have an e-mail deal with, you understand how flooded your inbox tends to get after an evening’s sleep. Advertising emails, private messages, skilled communications, and so forth, particularly in case you are a busy working skilled. The frustration of a cluttered inbox will be felt within the picture under:
The worst half is that even after creating related labels within the e-mail (Gmail within the case of the creator), one has to take the time to assign these emails to the proper label. With the developments in generative AI, shouldn’t it’s a lot simpler to kind and label emails in Gmail? Why don’t we cut back the steps of sorting related emails to a single click on?
Let me illustrate how we are able to use crewAI to construct an LLM agent and automate this course of. The tip aim is routinely sorting our unread emails utilizing crewAI into three classes: ‘Reply Instantly’, ‘No Reply’, and ‘Irrelevant’. We then add these categorised emails to Gmail and the respective labels.
Be aware: We manually created these labels – ‘Reply Instantly’, ‘No Reply’, and ‘Irrelevant’ – in Gmail.
Additionally Learn: Prime 10 AI Electronic mail Automation Instruments to Use in 2024
Steps for Google Authentication
Earlier than we soar to the code to kind emails in Gmail, you might want to allow the Gmail API and generate the OAuth 2.0 credentials. This can assist your e-mail sorting agentic system entry your emails. Listed here are the steps to do that.
Step 1: Create a New Challenge in Google Cloud
Step one in a Google authentication course of is to create a brand new venture in Google Cloud.
- 1. Go to the Google Cloud console and log in along with your e-mail deal with. First-time customers should create an account.
- Then choose “New Challenge” within the dropdown, give it a reputation, and click on Create. This venture can have the required API-related configurations. Whereas including the brand new venture, select your organisation identify as the situation, as we have now chosen analyticsvidhya.com
Step 2: Allow Gmail API
The subsequent step is to allow Gmail API.
- 1. Click on the Navigation Menu from the console’s Dashboard to Discover and Allow APIs underneath “Getting Began.“
- On the left aspect of the display, choose Library and seek for “Gmail API.” Then, please allow it for the venture you created.
Step 3: Set Up OAuth 2.0 Credentials
The final step in Google Authentication is to arrange OAuth 2.0 credentials.
- First, arrange the OAuth consent display underneath APIs & Companies >. Click on Configure Consent Display screen.
- Select the sort (e.g., Exterior for apps utilized by anybody). We selected Inner since we’re utilizing it for our e-mail ID. Then Click on Create.
- Identify your app and add the Consumer help e-mail and Developer contact data. Ideally, you must add your work e-mail ID. Click on SAVE AND CONTINUE on the backside of the display.
- Now, Outline the scopes within the consent display setup. Scopes within the context of Google Console dictate what the API can entry. For email-related duties, you’ll want the next: ‘https://www.googleapis.com/auth/gmail.modify‘. This scope will permit our e-mail sorting and labelling system to ship and modify emails in your Gmail account.
Click on on ADD OR REMOVE SCOPES after which choose the scope talked about above.
- Click on on Replace. You possibly can see the scope has been added. Press SAVE AND CONTINUE.
- Undergo the abstract and click on BACK TO DASHBOARD.
Step 4: Creating Credentials
- Now, select Credentials underneath APIs & Companies and click on CREATE CREDENTIALS.
- For native improvement, we’ll select the Desktop App choice. After which press CREATE.
Step 5: Obtain the Credential.json
- Now obtain the JSON file and reserve it domestically at your most popular location.
Python Code for Sorting and Labelling Emails Utilizing crewAI
We’ll now start coding the e-mail sorting and labelling system utilizing crewAI. Guarantee you’ve gotten put in crewAI and utils.
Set up crewAI
#pip set up crewai==0.28.8 crewai_tools==0.1.6
#pip set up utils
#pip set up google-auth-oauthlib
#pip set up google-api-python-client
Import Libraries
Now, we’ll import the related libraries.
# Import customary libraries
import json # For working with JSON information
import os # For interacting with the working system
import os.path # For manipulating filesystem pathnames
import pickle # For serializing and deserializing Python objects
# Import Google API consumer libraries for authentication and API requests
from google.auth.transport.requests import Request # For making authenticated HTTP requests
from google.oauth2.credentials import Credentials # For dealing with OAuth 2.0 credentials
from google_auth_oauthlib.movement import InstalledAppFlow # For managing OAuth 2.0 authorization flows
from googleapiclient.discovery import construct # For establishing a Useful resource object for interacting with an API
from googleapiclient.errors import HttpError # For dealing with HTTP errors from API requests
# Import customized libraries (assuming these are your individual modules or third-party packages)
from crewai import Agent, Activity, Crew # For managing brokers, duties, and crews
from crewai_tools import Device # For added instruments and utilities
# Import pandas library
import pandas as pd # For information manipulation and evaluation
Entry to LLM
After this, we’ll give our e-mail sorter and labeller entry to an LLM. I’m utilizing the GPT 4o mannequin for this activity, however you may select the LLM of your selection.
# Set OpenAI API key
os.environ['OPENAI_API_KEY'] = "Your API Key"
os.environ["OPENAI_MODEL_NAME"] = 'Mannequin Identify’'
Now, we’ll create the EmailCollector activity, which makes use of Google’s API to work together with Gmail and fetch unread emails.
class EmailCollector:
def __init__(self):
self.creds = None
self._authenticate()
def _authenticate(self):
SCOPES = ['https://www.googleapis.com/auth/gmail.modify'] # Use modify to replace emails
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
self.creds = pickle.load(token)
if not self.creds or not self.creds.legitimate:
if self.creds and self.creds.expired and self.creds.refresh_token:
self.creds.refresh(Request())
else:
movement = InstalledAppFlow.from_client_secrets_file(
'/Customers/admin/Desktop/Blogs/credentials.json', SCOPES)
self.creds = movement.run_local_server(port=0)
with open('token.pickle', 'wb') as token:
pickle.dump(self.creds, token)
def get_unread_emails(self):
service = construct('gmail', 'v1', credentials=self.creds)
outcomes = service.customers().messages().record(userId='me', q='is:unread').execute()
messages = outcomes.get('messages', [])
email_list = []
if not messages:
print('No unread emails discovered.')
else:
for message in messages:
msg = service.customers().messages().get(userId='me', id=message['id'], format="full").execute()
email_list.append(msg)
return email_list
Code Clarification
Here’s what the above code does:
- First, the EmailCollector initialises with self.creds = None and calls the _authenticate technique to deal with authentication.
- Then, the _authenticate technique checks if a token.pickle file exists. If it exists, it masses the saved credentials from the file utilizing pickle.
- If credentials are expired or lacking, it checks if a refresh token is offered to refresh them. If not, it initiates an OAuth movement utilizing InstalledAppFlow, prompting the consumer to log in.
- After acquiring the credentials (new or refreshed), they’re saved to the token pickle for future use.
- The get_unread_emails technique retrieves an inventory of unread emails after connecting to the Gmail API utilizing the authenticated credentials.
- It loops by every unread e-mail, retrieves full message particulars, and shops them within the email_list.
- Lastly, the record of unread emails is returned for additional use.
Create Mail Information Gatherer
Now, we’ll create the mailDataGatherer() operate to collect the unread emails and save them as a .csv file.
def mailDataGatherer():
# Create the Electronic mail Collector occasion
email_collector_instance = EmailCollector()
# Get unread emails
email_list = email_collector_instance.get_unread_emails()
# Put together information for DataFrame
emails_data = []
for e-mail in email_list:
topic = subsequent(header['value'] for header in e-mail['payload']['headers'] if header['name'] == 'Topic')
physique = ''
if 'components' in e-mail['payload']:
for half in e-mail['payload']['parts']:
if half['mimeType'] == 'textual content/plain':
physique = half['body']['data']
break
else:
physique = e-mail['payload']['body']['data']
import base64
physique = base64.urlsafe_b64decode(physique).decode('utf-8')
emails_data.append({
'Topic': topic,
'Physique': physique
})
# Create a DataFrame
df = pd.DataFrame(emails_data)
# Save DataFrame to CSV
df.to_csv('unread_emails.csv', index=False)
df.fillna("",inplace=True)
# Print the DataFrame
return df
Code Clarification
Right here is a proof of the above code:
- First, the operate handles authentication and retrieves unread emails utilizing an occasion of the EmailCollector class.
- Then, we fetch the unread emails utilizing the get_unread_emails() technique from the EmailCollector occasion.
- After that, we course of the e-mail information contained in the loop, which is
- The operate extracts the topic from the e-mail headers for every e-mail within the record.
- It checks the e-mail’s physique, decoding it from base64 format to get the precise textual content.
- It collects each the topic and physique of the emails.
- We’ll retailer the processed e-mail information (topic and physique) in a Pandas DataFrame.
- The DataFrame is saved as a CSV file referred to as unread_emails.csv, and any lacking values are full of empty strings.
- Lastly, the operate returns the DataFrame for additional use or viewing.
Now, we’ll create the extract_mail_tool for our agent utilizing the Device performance inside crewAI. This device will use the emaiDataGatherer operate to collect the topic and physique of the unread e-mail.
# Create the Extract Topics device
extract_mail_tool = Device(
identify="mailDataGatherer",
description="Get all the themes and physique content material of unread emails.",
func=mailDataGatherer
)
Now, we’ll create a operate that takes within the JSON illustration of the unread emails. It then decodes the emails and labels the corresponding emails in our Gmail inbox as per the pre-defined classes – ‘Reply Instantly’, ‘No Reply’, and ‘Irrelevan.t’
def push_mail_label(dfjson):
emails = pd.DataFrame(json.masses(dfjson.change("```","").change("json","")))
SCOPES = ['https://www.googleapis.com/auth/gmail.modify'] # Use modify to replace emails
#Change the identify and path of your file under accordingly
movement = InstalledAppFlow.from_client_secrets_file(
'/Customers/admin/Desktop/Blogs/credentials.json', SCOPES)
creds = movement.run_local_server(port=0)
service = construct('gmail', 'v1', credentials=creds)
labels = service.customers().labels().record(userId='me').execute().get('labels', [])
label_map = {label['name']: label['id'] for label in labels}
def get_or_create_label(label_name):
if label_name in label_map:
return label_map[label_name]
else:
# Create new label if it would not exist
new_label = {
'labelListVisibility': 'labelShow',
'messageListVisibility': 'present',
'identify': label_name
}
created_label = service.customers().labels().create(userId='me', physique=new_label).execute()
return created_label['id']
# Map the classes to Gmail labels, creating them if they do not exist
category_label_map = {
"Reply Instantly": get_or_create_label("Reply Instantly"),
"No Reply": get_or_create_label("No Reply"),
"Irrelevant": get_or_create_label("Irrelevant")
}
for i in vary(emails.form[0]):
topic = emails.iloc[i]['Subject']
physique = emails.iloc[i]['Body']
class = emails.iloc[i]['Category']
search_query = f'topic:("{topic}")'
outcomes = service.customers().messages().record(userId='me', q=search_query).execute()
message_id = outcomes['messages'][0]['id'] # Get the primary matching message ID
label_id = category_label_map.get(class, None)
# Apply label primarily based on class
if label_id:
service.customers().messages().modify(
userId='me',
id=message_id,
physique={
'addLabelIds': [label_id],
'removeLabelIds': [] # Optionally add label removing logic right here
}
).execute()
print(f'Up to date e-mail with topic: {topic} to label: {class}')
else:
print(f'Class {class} doesn't match any Gmail labels.')
return
How does this operate work?
The operate works as follows:
- The dfjson string is first cleaned of additional characters. It’s then parsed right into a Pandas DataFrame that comprises columns like Topic, Physique, and Class for every e-mail.
- Then, with Google OAuth 2.0, the operate authenticates with Gmail by InstalledAppFlow utilizing the gmail.modify scope. This enables it to change emails (including labels in our case).
- Subsequent, the operate retrieves all current Gmail labels from the consumer’s account and shops them in a label_map dictionary (label identify to label ID).
- After that, the get_or_create_label() operate checks if a label already exists. If not, it creates a brand new one utilizing the Gmail API.
- Subsequent, it maps the classes within the e-mail information to their respective Gmail labels (Reply Instantly, No Reply, Irrelevant), creating them if essential.
- For every e-mail, the operate searches Gmail for an identical message by the topic, retrieves the message ID and applies the corresponding label primarily based on the class.
- On the finish, the operate prints a message indicating success or failure for every e-mail it processes.
Defining the Electronic mail Sorting Agent
This agent will classify the unread emails into three classes we have now outlined. The agent makes use of the extract_mail_tool to entry the emails, which makes use of the mailDataGatherer() operate to get the emails. Since this agent makes use of LLM, you should give correct directions on what is predicted to be finished. For instance, one express instruction I’ve added is concerning the form of mail that have to be included in every bit of content material. You possibly can learn the directions additional within the agent’s backstory parameter.
sorter = Agent(
function="Electronic mail Sorter",
aim="Clasify the emails into one of many 3 classes supplied",
instruments=[extract_mail_tool], # Add instruments if wanted
verbose=True,
backstory=(
"You might be an knowledgeable private assistant working for a busy company skilled."
"You might be dealing with the non-public e-mail account of the CEO."
"You might have been assigned a activity to categorise the unread emails into one of many three classes."
"Checklist of the three classes is : ['Reply Immediately', 'No Reply' and 'Irrelevant']"
"'Reply Instantly' ought to embody unread emails from throughout the group and out of doors. This is usually a basic inquiry, question and calender invitations."
"'No Reply' contains unread emails the place somebody is letting me know of some improvement throughout the firm. It additionally contains Newsletters that I've subscribed to."
"'Irrelevant' comprises unread emails which can be from exterior companies advertising there merchandise."
"You possibly can apply your individual intelligence whereas sorting the unread emails."
"You get the info of unread mails in a pandas dataframe utilizing the device mailDataGatherer."
"You're going to get 'Topic' and 'Physique' columns within the dataframe returned by device."
"You need to classify the mails on foundation of topic and physique and name it 'Class'."
"There isn't any device which you should use for classification. Use your individual intelligence to do it."
"Lastly you come a json with 3 keys for every mail: 'Topic', 'Physique', 'Class'"
)
)
Be aware that we have now set verbose = True, which helps us view how the mannequin thinks.
Outline the Activity
Now, we’ll outline the Activity that the sorter agent will carry out. We’ve added the precise record of duties, which you’ll be able to learn within the code under.
# Activity for Sorter: Type Emails
sort_task = Activity(
aim="Type the categorised emails into: ['Reply Immediately', 'No Reply' and 'Irrelevant'] ",
description= "1. At first, get the dataframe of unread emails utilizing the 'mailDataGatherer'."
"2. Don't use the device once more after getting acquired the topic and physique"
"3. Classify the emails into one of many above classes: ['Reply Immediately', 'No Reply' and 'Irrelevant']."
"4. There isn't any device which you should use for classification. Use the directions and your individual intelligence to do it."
"5. Lastly, return a json with three keys for every row: ['Subject', 'Body', 'Category']"
"6. All of the emails should strictly be categorised into certainly one of above three classes solely.",
expected_output = "A json file with all of the unread emails. There needs to be 3 keys for every mail- Topic, Physique and Class ",
agent=sorter,
async_execution=False
)
Allow Collaboration in CrewAI
Subsequent, we’ll use crewAI’s performance to allow collaboration and let the sorter agent carry out the duties outlined within the sort_task operate above.
# Create the Crew
email_sorting_crew = Crew(
brokers=[sorter],
duties=[sort_task],
verbose=True
)
Lastly, we'll kickoff our crew to let it kind the unread emails routinely and save the output within the end result variable.
# Working the crew
end result = email_sorting_crew.kickoff()
Since verbose = True for all components in our agent, we get to see how our agent performs.
Now, we push this end result into our Gmail utilizing the push_mail_label() operate.
#push the outcomes
push_mail_label(end result)
Be aware that all through the execution, you’ll be twice redirected to a unique window to offer the mandatory permissions. As soon as the code can reaccess the emails, the unread emails shall be pushed underneath the related labels.
And Voila! We’ve the emails with labels connected. For privateness, I cannot show my complete inbox.
Conclusion
Bear in mind the frustration we mentioned earlier within the weblog? Nicely, crewAI’s e-mail sorting and labelling agentic system permits us to save lots of a big period of time.
With LLM brokers, the probabilities of activity automation are limitless. It will depend on how nicely you suppose and construction your agentic system. As a subsequent step, you may strive constructing an agent that checks whether or not the primary agent’s categorisation is right. Or, you may also strive creating an agent that prepares an e-mail for the ‘Reply Instantly’ class and pushes it to the drafts in Gmail. Sounds formidable? So, go on and get your palms soiled. Completely happy studying!!
Steadily Requested Questions
A. crewAI is an open-source Python framework that helps creating and managing multi-agent AI techniques. Utilizing crewAI, you may construct LLM-backed AI brokers that may autonomously make choices inside an setting primarily based on the variables current.
A. Sure! You should utilize crewAI to construct LLM-backed brokers to automate e-mail sorting and labelling duties.
A. Relying in your agentic system construction, you should use as many brokers as you wish to kind emails in Gmail. Nonetheless, it’s endorsed that you simply construct one agent per activity.
A. CrewAI can carry out numerous duties, together with sorting and writing emails, planning tasks, producing articles, scheduling and posting social media content material, and extra.
A. Since GenAI brokers utilizing crewAI make choices utilizing LLMs, it reduces the requirement to allocate human assets to undergo emails and make choices.
A. To automate e-mail sorting utilizing crewAI, you should outline the brokers with a descriptive backstory throughout the Agent operate, outline duties for every agent utilizing the Activity performance, after which create a Crew to allow completely different brokers to collaborate.