email support

app.py

@@ -5,8 +5,9 @@ import pytz
 import time
 import json
 import re
+import random
+import string
 from transformers import AutoTokenizer
-from gradio_client import Client
 from tools import toolsInfo
 
 from dotenv import load_dotenv
@@ -18,6 +19,7 @@ if useGpt4:
     from openai import OpenAI
     client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
     MODEL = "gpt-4o-mini"
+    TOOLS_MODEL = "gpt-4o-mini"
     MAX_CONTEXT = 128000
     tokenizer = AutoTokenizer.from_pretrained("Xenova/gpt-4o")
 else:
@@ -26,7 +28,8 @@ else:
         api_key=os.environ.get("GROQ_API_KEY"),
     )
     MODEL = "llama-3.1-70b-versatile"
-    MODEL = "llama3-groq-70b-8192-tool-use-preview"
+    # MODEL = "llama3-groq-70b-8192-tool-use-preview"
+    TOOLS_MODEL = "llama3-groq-70b-8192-tool-use-preview"
     MAX_CONTEXT = 8000
     tokenizer = AutoTokenizer.from_pretrained("Xenova/Meta-Llama-3.1-Tokenizer")
 
@@ -37,18 +40,62 @@ def countTokens(text):
     return len(tokens)
 
 
-SYSTEM_MSG = f"""
-You are a personalized email generator for cold outreach. You take the user through a workflow. Step by step.
+SYSTEM_MSG = """
+You are a personalized email generator for cold outreach. You take the user through the below workflow.
+Keep your questions crisp. Ask only one question at a time.
 
-- You ask for industry of the recipient
-- His/her role
-- More details about the recipient
+# You ask about the purpose of sending email.
+Give well-formatted numbered options to choose from for the email purpose.
+Group the options by category as described below.
+Give numbers only to the options and not categories.
+Give a line break after every category name.
 
-Highlight the exact entity you're requesting for by making it CAPITAL CASE.
-Once collected, you store these info in a Google Sheet
+##### Category: Acquiring Customers
+- Lead Generation (spark interest in possible customers)
+- Sales Outreach (directly ask the decision-makers)
+- Partnership and Collaboration (build mutually beneficial relationships)
+- Event Promotion (invite people to webinars, conferences, or other events)
+- Case study or testimonial requests (ask satisfied customers for testimonials)
 
+##### Category: Learning and Connecting
+- Networking (establish connections with industry experts)
+- Market Research (gather information about target audiences or industries)
+- Career Advice (seek guidance from experienced professionals)
+
+##### Category: Jobs and Hiring
+- Job Application (apply for job openings)
+- Job Referrals (ask for referrals or recommendations)
+- Recruitment (reach out to potential candidates)
+
+
+# You then ask sender (user) details. Whatever could be relevant for this type of email
+# You ask for recipient's Industry, if it's required for this type of email
+# You ask for recipient's Role in the company, if it's required for this type of email
+# You ask for any other specific details required to draft this type of mail
+# Once all these details are received, you save them in a Google Sheet
+
+# You then check with the user if they can see details in the sheet.
+
+# Once the user ackowledges, you move to the next phase of email generation.
+Based on the above info, you draft 2 very different variations of email and check the user which one they're liking more.
+Keep the email body in sections separated by divider "-----".
+Give numbered options at the end to choose from.
+Ask them if they want to finalize it. If they don't finalize, repeat doing it till the user finalizes on one.
+Check with them what they would like to change in the variation.
+
+# Once the mail is finalized. You ask the user for all the missing placeholder values to write the final mail.
+
+# Once the placeholder values are available in the final email, you ask for the recipient email ID.
+
+# Once you have the final mail with placeholder values and recipient exact email ID, you send the email to this id.
+Dont send email until you have received a valid email from user.
+
+# You congratulate the user and ask if he would like to save this email as a template. If he agrees, save this template in Google Sheet.
+
+# Repeat the process for more profiles and recipients.
 """
 
+
 USER_ICON = "icons/man.png"
 ASSISTANT_ICON = "icons/magic-wand-1.png"
 TOOL_ICON = "icons/check.png"
@@ -124,7 +171,7 @@ def __isInvalidResponse(response: str):
         return True
 
     # lots of paragraphs
-    if len(re.findall(r'\n\n', response)) > 15:
+    if len(re.findall(r'\n\n', response)) > 25:
         return True
 
 
@@ -165,7 +212,9 @@ def __getMessages():
 
 
 tools = [
-    toolsInfo["saveInGSheet"]["schema"]
+    toolsInfo["saveProfileDetailsInGSheet"]["schema"],
+    toolsInfo["saveTemplateInGSheet"]["schema"],
+    toolsInfo["sendEmail"]["schema"],
 ]
 
 
@@ -180,14 +229,10 @@ def __showToolResponse(toolResponseDisplay: dict):
             width=30
         )
     with col2:
-        st.markdown(
-            f"""
-            <div class='code'>
-            {msg}
-            </div>
-            """,
-            unsafe_allow_html=True
-        )
+        if "`" not in msg:
+            st.markdown(f"`{msg}`")
+        else:
+            st.markdown(msg)
 
 
 def __process_stream_chunk(chunk):
@@ -199,25 +244,6 @@ def __process_stream_chunk(chunk):
     return None
 
 
-def __addToolCallsToMsgs(toolCalls):
-    st.session_state.messages.append(
-        {
-            "role": "assistant",
-            "tool_calls": [
-                {
-                    "id": toolCall.id,
-                    "function": {
-                        "name": toolCall.function.name,
-                        "arguments": toolCall.function.arguments,
-                    },
-                    "type": toolCall.type,
-                }
-                for toolCall in toolCalls
-            ],
-        }
-    )
-
-
 def __addToolCallToMsgs(toolCall: dict):
     st.session_state.messages.append(
         {
@@ -240,9 +266,11 @@ def __processToolCalls(toolCalls):
     for toolCall in toolCalls:
         functionName = toolCall.function.name
         functionToCall = toolsInfo[functionName]["func"]
-        functionArgs = json.loads(toolCall.function.arguments)
+        functionArgsStr = toolCall.function.arguments
+        pprint(f"{functionName=} | {functionArgsStr=}")
+        functionArgs = json.loads(functionArgsStr)
         functionResult = functionToCall(**functionArgs)
-        functionResponse = functionResult["response"]
+        functionResponse = functionResult.get("response")
         responseDisplay = functionResult.get("display")
         pprint(f"{functionResponse=}")
 
@@ -274,50 +302,66 @@ def __dedupeToolCalls(toolCalls: list):
     return dedupedToolCalls
 
 
-def predict():
-    shouldStream = False
+def __getRandomToolId():
+    return ''.join(
+        random.choices(
+            string.ascii_lowercase + string.digits,
+            k=4
+        )
+    )
+
+
+def predict(model: str = None):
+    model = model or MODEL
 
     messagesFormatted = [{"role": "system", "content": SYSTEM_MSG}]
     messagesFormatted.extend(__getMessages())
     contextSize = countTokens(messagesFormatted)
-    pprint(f"{contextSize=} | {MODEL}")
+    pprint(f"{contextSize=} | {model}")
     pprint(f"{messagesFormatted=}")
 
     response = client.chat.completions.create(
-        model=MODEL,
+        model=model,
         messages=messagesFormatted,
-        temperature=0.8,
+        temperature=0.5,
         max_tokens=4000,
-        stream=shouldStream,
+        stream=False,
         tools=tools
     )
-    # pprint(f"llmResponse: {response}")
-
-    if shouldStream:
-        content = ""
-        toolCall = None
-
-        # for chunk in response:
-        #     chunkContent = __process_stream_chunk(chunk)
-        #     if isinstance(chunkContent, str):
-        #         content += chunkContent
-        #         yield chunkContent
-        #     elif chunkContent:
-        #         if not toolCall:
-        #             toolCall = chunkContent
-        #         else:
-        #             toolCall.function.arguments += chunkContent.function.arguments
-
-        # toolCalls = [toolCall] if toolCall else []
-    else:
-        responseMessage = response.choices[0].message
-        # pprint(f"{responseMessage=}")
-        responseContent = responseMessage.content
-        # pprint(f"{responseContent=}")
-        if responseContent:
-            yield responseContent
-        toolCalls = responseMessage.tool_calls
-        # pprint(f"{toolCalls=}")
+
+    responseMessage = response.choices[0].message
+    # pprint(f"{responseMessage=}")
+    responseContent = responseMessage.content
+    # pprint(f"{responseContent=}")
+
+    if responseContent and '<function=' in responseContent:
+        pprint("Switching to TOOLS_MODEL")
+        return predict(TOOLS_MODEL)
+
+    # if responseContent and responseContent.startswith('<function='):
+    #     function_match = re.match(r'<function=(\w+)>(.*?)</+function>', responseContent)
+    #     if function_match:
+    #         function_name, function_args = function_match.groups()
+    #         toolCalls = [
+    #             {
+    #                 "id": __getRandomToolId(),
+    #                 "type": "function",
+    #                 "function": {
+    #                     "name": function_name,
+    #                     "arguments": function_args
+    #                 }
+    #             }
+    #         ]
+    #         responseContent = None  # Set content to None as it's a function call
+    #     else:
+    #         toolCalls = None
+    # else:
+    #     toolCalls = responseMessage.tool_calls
+
+    if responseContent:
+        yield responseContent
+    toolCalls = responseMessage.tool_calls
+    # pprint(f"{toolCalls=}")
 
     if toolCalls:
         pprint(f"{toolCalls=}")
@@ -329,7 +373,7 @@ def predict():
             pprint(e)
 
 
-st.title("EmailGenie 💌")
+st.title("EmailGenie 📧🧞‍♂️")
 if not (st.session_state["buttonValue"] or st.session_state["startMsg"]):
     st.button(START_MSG, on_click=lambda: __setStartMsg(START_MSG))
 
@@ -369,7 +413,7 @@ if prompt := (st.chat_input() or st.session_state["buttonValue"] or st.session_s
             for chunk in responseGenerator:
                 response += chunk
                 if __isInvalidResponse(response):
-                    pprint(f"{response=}")
+                    pprint(f"Invalid_{response=}")
                     return
                 responseContainer.markdown(response)
 
@@ -387,28 +431,6 @@ if prompt := (st.chat_input() or st.session_state["buttonValue"] or st.session_s
             st.session_state["buttonValue"] = optionLabel
             pprint(f"Selected: {optionLabel}")
 
-        # responseParts = response.split(JSON_SEPARATOR)
-
-        # jsonStr = None
-        # if len(responseParts) > 1:
-        #     [response, jsonStr] = responseParts
-
-        # if jsonStr:
-        #     try:
-        #         json.loads(jsonStr)
-        #         jsonObj = json.loads(jsonStr)
-        #         options = jsonObj["options"]
-
-        #         for option in options:
-        #             st.button(
-        #                 option["label"],
-        #                 key=option["id"],
-        #                 on_click=lambda label=option["label"]: selectButton(label)
-        #             )
-        #         # st.code(jsonStr, language="json")
-        #     except Exception as e:
-        #         pprint(e)
-
         toolResponseDisplay = st.session_state.toolResponseDisplay
         st.session_state.chatHistory.append({
             "role": "assistant",
@@ -420,4 +442,3 @@ if prompt := (st.chat_input() or st.session_state["buttonValue"] or st.session_s
             "role": "assistant",
             "content": response,
         })
-

requirements.txt

@@ -3,4 +3,5 @@ groq
 transformers
 gradio_client
 oauth2client
-gspread
+gspread
+sendgrid

tools.py

@@ -2,22 +2,29 @@
 import gspread
 import os
 import json
+from sendgrid import SendGridAPIClient
+from sendgrid.helpers.mail import Mail
 
-# from dotenv import load_dotenv
-# load_dotenv()
+from dotenv import load_dotenv
+load_dotenv()
 
 GCP_JSON_KEY = os.environ.get("GCP_JSON_KEY")
 MY_EMAIL = "[email protected]"
+TEMPLATE_COL_NAME = "Template"
 
+sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
 
-def saveInGSheet(
-    industry: str,
-    role: str,
-    profileDetails: str
+
+def saveProfileDetailsInGSheet(
+    emailPurpose,
+    aboutYou,
+    recipientIndustry,
+    recipientRole,
+    specificDetails
 ):
     client = gspread.service_account_from_dict(json.loads(GCP_JSON_KEY))
 
-    workBook = "Cold Outreach - User Prof"
+    workBook = "Cold Mail Outreach - User Profiles"
     try:
         spreadsheet = client.open(workBook)
     except gspread.SpreadsheetNotFound:
@@ -30,49 +37,176 @@ def saveInGSheet(
             role='writer',
         )
 
-    sheet = spreadsheet.sheet1
+    sheet = spreadsheet.worksheet("Profiles & Templates")
     sheet.append_row([
-        industry,
-        role,
-        profileDetails
+        emailPurpose,
+        aboutYou,
+        recipientIndustry,
+        recipientRole,
+        specificDetails
     ])
+    if not (emailPurpose and aboutYou):
+        return {}
     return {
-        "response": f"Saved in Google Sheet. [Link]({spreadsheet.url})",
+        "response": "Saved profile details in Google Sheet.",
         "display": {
-            "text": "Saved in Google Sheet",
+            "text": f"`Saved profile details in Google Sheet` [Link]({spreadsheet.url})",
             "icon": "icons/completed-task.png",
         }
     }
 
 
+def saveTemplateInGSheet(template: str):
+    client = gspread.service_account_from_dict(json.loads(GCP_JSON_KEY))
+
+    workBook = "Cold Mail Outreach - User Profiles"
+    try:
+        spreadsheet = client.open(workBook)
+    except gspread.SpreadsheetNotFound:
+        print(f"Sheet not found: {workBook}")
+        return {
+            "response": "Failed to save template. Sheet not found.",
+            "display": {
+                "text": "`Failed to save template. Sheet not found.`",
+                "icon": "icons/error.png",
+            }
+        }
+
+    sheet = spreadsheet.worksheet("Profiles & Templates")
+
+    headers = sheet.row_values(1)
+    templateColIndex = headers.index(TEMPLATE_COL_NAME) + 1
+    lastRow = len([row for row in sheet.get_all_values() if any(row)])
+
+    sheet.update_cell(lastRow, templateColIndex, template)
+
+    return {
+        "response": "Saved template in Google Sheet.",
+        "display": {
+            "text": f"`Saved template in Google Sheet` [Link]({spreadsheet.url})",
+            "icon": "icons/completed-task.png",
+        }
+    }
+
+
+def sendEmail(
+    toEmail: str,
+    subject: str,
+    htmlContent: str
+):
+    message = Mail(
+        from_email=MY_EMAIL,
+        to_emails=toEmail,
+        subject=subject,
+        html_content=htmlContent,
+    )
+    try:
+        sg.send(message)
+        return {
+            "response": "Email sent",
+            "display": {
+                "text": f"`Email sent to {toEmail}`",
+                "icon": "icons/mail.png",
+            }
+        }
+    except Exception as e:
+        print(e.message)
+        return {
+            "response": f"Failed to send email. Error: {e.message}",
+            "display": {
+                "text": f"`Failed to send email to {toEmail}`",
+                "icon": "icons/error.png",
+            }
+        }
+
+
 toolsInfo = {
-    "saveInGSheet": {
-        "func": saveInGSheet,
+    "saveProfileDetailsInGSheet": {
+        "func": saveProfileDetailsInGSheet,
         "schema": {
             "type": "function",
             "function": {
-                "name": "saveInGSheet",
-                "description": "Saves the profile details in Google Sheet",
+                "name": "saveProfileDetailsInGSheet",
+                "description": "Saves the email profile details in Google Sheet",
                 "parameters": {
                     "type": "object",
                     "properties": {
-                        "industry": {
+                        "emailPurpose": {
+                            "type": "string",
+                            "description": "Purpose of the email"
+                        },
+                        "aboutYou": {
                             "type": "string",
-                            "description": "Industry of the person"
+                            "description": "A bit about you that's required for email content"
                         },
-                        "role": {
+                        "recipientIndustry": {
                             "type": "string",
-                            "description": "Role of the person in the Company"
+                            "description": "Industry of the recipient"
                         },
-                        "profileDetails": {
+                        "recipientRole": {
                             "type": "string",
-                            "description": "Profile details of the person"
+                            "description": "Recipient's role in the company"
+                        },
+                        "specificDetails": {
+                            "type": "string",
+                            "description": "Any specific details about the email"
                         }
+
                     },
-                    "required": ["industry", "role", "profileDetails"]
+                    "required": ["emailPurpose", "aboutYou", "recipientIndustry"]
                 }
             }
         },
-    }
-}
+    },
+
+    "saveTemplateInGSheet": {
+        "func": saveTemplateInGSheet,
+        "schema": {
+            "type": "function",
+            "function": {
+                "name": "saveTemplateInGSheet",
+                "description": "Saves the email template in Google Sheet",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "template": {
+                            "type": "string",
+                            "description": "Email template"
+                        }
+                    },
+                    "required": ["template"]
+                }
+            }
+        },
+    },
+
+    "sendEmail": {
+        "func": sendEmail,
+        "schema": {
+            "type": "function",
+            "function": {
+                "name": "sendEmail",
+                "description": "Sends an email to the user",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "toEmail": {
+                            "type": "string",
+                            "description": "Email address of the recipient"
+                        },
+                        "subject": {
+                            "type": "string",
+                            "description": "Subject of the email"
+                        },
+                        "htmlContent": {
+                            "type": "string",
+                            "description": "HTML content of the email"
+                        }
+                    },
+                    "required": ["toEmail", "subject", "htmlContent"]
+                }
+            }
+        },
+    },
 
+}