Upload 9 files

app (3).py

@@ -0,0 +1,62 @@
+# app.py
+# Filepath: ai-email-assistant/app.py
+# Main application entry point
+
+import json
+import gradio as gr
+from chat import create_chat_interface
+from profile_management import create_profile_management_interface, get_profile_summaries
+from email_actions import create_email_actions_interface, get_template_summaries
+from groq_client import set_api_key
+from google_sheets_utils import connect_to_sheets
+
+def load_config():
+    try:
+        with open('config.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+def main():
+    config = load_config()
+    api_key = config.get('groq_api_key')
+    if api_key:
+        set_api_key(api_key)
+    
+    sender_sheet, receiver_sheet, template_sheet = connect_to_sheets()
+    
+    with gr.Blocks() as app:
+        gr.Markdown("# AI Email Assistant")
+        
+        # State variables
+        current_sender = gr.State(None)
+        current_receiver = gr.State(None)
+        current_template = gr.State(None)
+        
+        with gr.Tabs():
+            with gr.Tab("Profile Management"):
+                with gr.Tabs():
+                    with gr.Tab("Sender Profiles"):
+                        sender_components = create_profile_management_interface(sender_sheet, "Sender", current_sender)
+                    with gr.Tab("Receiver Profiles"):
+                        receiver_components = create_profile_management_interface(receiver_sheet, "Receiver", current_receiver)
+            
+            with gr.Tab("Email Actions"):
+                email_actions_components = create_email_actions_interface(template_sheet, current_template)
+            
+            with gr.Tab("Chat"):
+                # Get summaries for context
+                sender_summaries = get_profile_summaries(sender_sheet)
+                receiver_summaries = get_profile_summaries(receiver_sheet)
+                template_summaries = get_template_summaries(template_sheet)
+                
+                chat_interface = create_chat_interface(
+                    sender_summaries, receiver_summaries, template_summaries,
+                    current_sender, current_receiver, current_template,
+                    sender_components, receiver_components, email_actions_components
+                )
+
+    app.launch()
+
+if __name__ == "__main__":
+    main()

chat.py

@@ -0,0 +1,95 @@
+# chat.py
+# Filepath: ai-email-assistant/chat.py
+# Implements the chat interface and message handling
+
+import gradio as gr
+from groq_client import get_ai_response
+from web_search import search_web
+from profile_management import get_profiles, create_profile, update_profile, delete_profile
+from email_actions import get_templates, create_template, update_template, delete_template
+
+def load_system_prompt(filename):
+    try:
+        with open(filename, 'r') as file:
+            return file.read().strip()
+    except FileNotFoundError:
+        return "System prompt file not found."
+
+def create_chat_interface(sender_summaries, receiver_summaries, template_summaries,
+                          current_sender, current_receiver, current_template,
+                          sender_components, receiver_components, email_actions_components):
+    main_system_prompt = load_system_prompt('system_prompt_main.txt')
+    function_call_prompt = load_system_prompt('system_prompt_function_call.txt')
+    
+    chatbot = gr.Chatbot()
+    msg = gr.Textbox()
+    clear = gr.Button("Clear")
+
+    def get_context():
+        context = "Current context:\n"
+        
+        if current_sender.value:
+            context += f"Current Sender: {current_sender.value}\n"
+        if current_receiver.value:
+            context += f"Current Receiver: {current_receiver.value}\n"
+        if current_template.value:
+            context += f"Current Template: {current_template.value}\n"
+        
+        context += f"Available Sender Profiles: {', '.join(sender_summaries)}\n"
+        context += f"Available Receiver Profiles: {', '.join(receiver_summaries)}\n"
+        context += f"Available Templates: {', '.join(template_summaries)}\n"
+        
+        return context
+
+    def execute_function(function_call):
+        # Implementation of function execution based on the function call
+        # This should handle all the functions mentioned in the system prompt
+        function_name = function_call.split('(')[0].strip()
+        args = [arg.strip().strip("'\"") for arg in function_call.split('(')[1].split(')')[0].split(',')]
+        
+        if function_name == 'load_sender_profile':
+            current_sender.value = args[0]
+            return f"Loaded sender profile: {args[0]}"
+        elif function_name == 'load_receiver_profile':
+            current_receiver.value = args[0]
+            return f"Loaded receiver profile: {args[0]}"
+        elif function_name == 'load_template':
+            current_template.value = args[0]
+            return f"Loaded template: {args[0]}"
+        # Add more function implementations as needed
+        
+        return "Function not implemented"
+
+    def respond(message, chat_history):
+        context = get_context()
+        
+        main_ai_response = get_ai_response(message, main_system_prompt, context + "\n".join([f"{m[0]}: {m[1]}" for m in chat_history]))
+        
+        if "Action required:" in main_ai_response:
+            action_context = main_ai_response.split("Action required:")[1].strip()
+            function_call_response = get_ai_response(action_context, function_call_prompt)
+            
+            if function_call_response.startswith('[SEARCH:'):
+                search_query = function_call_response[8:-1].strip()
+                result = "\n".join(search_web(search_query))
+            elif function_call_response.startswith('[FUNCTION:'):
+                function_call = function_call_response[10:-1].strip()
+                result = execute_function(function_call)
+            else:
+                result = "Invalid backend response"
+            
+            final_response = get_ai_response(
+                f"Previous context: {action_context}\n\nAction result: {result}\n\nPlease continue the conversation with the user based on this result.",
+                main_system_prompt,
+                "\n".join([f"{m[0]}: {m[1]}" for m in chat_history])
+            )
+        else:
+            final_response = main_ai_response
+
+        chat_history.append((message, final_response))
+        return "", chat_history
+
+    msg.submit(respond, [msg, chatbot], [msg, chatbot])
+    clear.click(lambda: None, None, chatbot, queue=False)
+
+    return chatbot, msg, clear

email_actions.py

@@ -0,0 +1,98 @@
+# email_actions.py
+# Filepath: ai-email-assistant/email_actions.py
+# Manages email-related actions (drafting, templating)
+
+import gradio as gr
+from google_sheets_utils import get_templates, save_template, delete_template_from_sheet
+
+def get_template_summaries(sheet):
+    templates = get_templates(sheet)
+    return [template[2] for template in templates]  # Assuming the name is in the third column
+
+def create_email_actions_interface(template_sheet, current_template):
+    with gr.Group():
+        gr.Markdown("## Email Actions")
+        
+        name = gr.Textbox(label="Template Name")
+        subject = gr.Textbox(label="Subject")
+        content = gr.Textbox(label="Content", lines=10)
+        sender_profile = gr.Dropdown(label="Sender Profile")
+        receiver_profile = gr.Dropdown(label="Receiver Profile")
+        
+        save_draft_btn = gr.Button("Save as Draft")
+        save_template_btn = gr.Button("Save as Template")
+        
+        templates_list = gr.Dataframe(
+            headers=["Type", "ID", "Name", "Subject", "Content", "Sender Profile", "Receiver Profile"],
+            label="Existing Templates",
+            value=get_templates(template_sheet),
+            interactive=False
+        )
+
+        load_template_btn = gr.Button("Load Selected Template")
+        delete_template_btn = gr.Button("Delete Selected Template")
+
+        def save_template_action():
+            template_data = {
+                "name": name.value,
+                "subject": subject.value,
+                "content": content.value,
+                "sender_profile": sender_profile.value,
+                "receiver_profile": receiver_profile.value
+            }
+            save_template(template_sheet, template_data)
+            return get_templates(template_sheet)
+
+        def load_template(evt: gr.SelectData):
+            if evt.value:
+                selected_template = templates_list.value[evt.index[0]]
+                current_template.value = selected_template[2]  # Set the current template to the selected name
+                return (
+                    selected_template[2],  # Name
+                    selected_template[3],  # Subject
+                    selected_template[4],  # Content
+                    selected_template[5],  # Sender Profile
+                    selected_template[6],  # Receiver Profile
+                )
+            return [gr.update() for _ in range(5)]
+
+        def delete_template(evt: gr.SelectData):
+            if evt.value:
+                template_id = templates_list.value[evt.index[0]][1]
+                delete_template_from_sheet(template_sheet, template_id)
+                return get_templates(template_sheet)
+            return templates_list.value
+
+        save_template_btn.click(save_template_action, outputs=[templates_list])
+        load_template_btn.click(load_template, outputs=[name, subject, content, sender_profile, receiver_profile])
+        delete_template_btn.click(delete_template, outputs=[templates_list])
+
+        refresh_btn = gr.Button("Refresh Templates")
+        refresh_btn.click(lambda: get_templates(template_sheet), outputs=[templates_list])
+
+    return name, subject, content, sender_profile, receiver_profile, save_draft_btn, save_template_btn, templates_list, load_template_btn, delete_template_btn, refresh_btn
+
+# Implement create_template, update_template, delete_template functions
+def create_template(sheet, name, subject, content, sender_profile, receiver_profile):
+    template_data = {
+        "name": name,
+        "subject": subject,
+        "content": content,
+        "sender_profile": sender_profile,
+        "receiver_profile": receiver_profile
+    }
+    return save_template(sheet, template_data)
+
+def update_template(sheet, template_id, name, subject, content, sender_profile, receiver_profile):
+    template_data = {
+        "id": template_id,
+        "name": name,
+        "subject": subject,
+        "content": content,
+        "sender_profile": sender_profile,
+        "receiver_profile": receiver_profile
+    }
+    return save_template(sheet, template_data)
+
+def delete_template(sheet, template_id):
+    return delete_template_from_sheet(sheet, template_id)

google_sheets_utils.py

@@ -0,0 +1,144 @@
+# google_sheets_utils.py
+# Filepath: ai-email-assistant/google_sheets_utils.py
+# Manages interactions with Google Sheets for profile and template storage
+
+import os
+import json
+import gspread
+from google.oauth2.service_account import Credentials
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def load_config():
+    with open('config.json', 'r') as f:
+        return json.load(f)
+
+# Setup Google Sheets connection
+SCOPES = ['https://www.googleapis.com/auth/spreadsheets',
+          'https://www.googleapis.com/auth/drive']
+config = load_config()
+creds_file = config.get('google_sheets_credentials_file')
+creds = Credentials.from_service_account_file(creds_file, scopes=SCOPES)
+client = gspread.authorize(creds)
+
+# Open the Google Sheet (create it if it doesn't exist)
+try:
+    spreadsheet = client.open("AI Email Assistant")
+    logger.info("Successfully opened the spreadsheet.")
+except gspread.exceptions.SpreadsheetNotFound:
+    logger.info("Spreadsheet 'AI Email Assistant' not found. Creating a new one.")
+    spreadsheet = client.create("AI Email Assistant")
+    logger.info("New spreadsheet 'AI Email Assistant' created.")
+
+def initialize_sheet(sheet, headers, sample_data):
+    if not sheet.get_all_values():
+        sheet.append_row(headers)
+        for row in sample_data:
+            sheet.append_row(row)
+        logger.info(f"Initialized {sheet.title} with headers and sample data.")
+
+def connect_to_sheets():
+    try:
+        sender_sheet = spreadsheet.worksheet("Sender Profiles")
+    except gspread.exceptions.WorksheetNotFound:
+        sender_sheet = spreadsheet.add_worksheet(title="Sender Profiles", rows="100", cols="20")
+    
+    try:
+        receiver_sheet = spreadsheet.worksheet("Receiver Profiles")
+    except gspread.exceptions.WorksheetNotFound:
+        receiver_sheet = spreadsheet.add_worksheet(title="Receiver Profiles", rows="100", cols="20")
+    
+    try:
+        template_sheet = spreadsheet.worksheet("Email Templates")
+    except gspread.exceptions.WorksheetNotFound:
+        template_sheet = spreadsheet.add_worksheet(title="Email Templates", rows="100", cols="20")
+
+    # Initialize sheets with headers and sample data if they're empty
+    profile_headers = ["Type", "ID", "Name", "Email", "Position", "Company", "Context"]
+    sender_sample = [
+        ["Sender", "SEND_1", "John Doe", "john@example.com", "Sales Manager", "ABC Corp", "Professional"],
+        ["Sender", "SEND_2", "Jane Smith", "jane@example.com", "Marketing Director", "XYZ Inc", "Professional"]
+    ]
+    receiver_sample = [
+        ["Receiver", "REC_1", "Alice Johnson", "alice@example.com", "CEO", "123 Industries", "Professional"],
+        ["Receiver", "REC_2", "Bob Brown", "bob@example.com", "HR Manager", "456 Corp", "Professional"]
+    ]
+    initialize_sheet(sender_sheet, profile_headers, sender_sample)
+    initialize_sheet(receiver_sheet, profile_headers, receiver_sample)
+
+    template_headers = ["Type", "ID", "Name", "Subject", "Content", "Sender Profile", "Receiver Profile"]
+    template_sample = [
+        ["Template", "TEMP_1", "Sales Pitch", "Exciting Offer!", "Dear {receiver_name},\n\nWe have an exciting offer for {receiver_company}...", "John Doe", "Alice Johnson"],
+        ["Template", "TEMP_2", "Follow-up", "Following up on our meeting", "Hello {receiver_name},\n\nI hope this email finds you well. I wanted to follow up on our recent meeting...", "Jane Smith", "Bob Brown"]
+    ]
+    initialize_sheet(template_sheet, template_headers, template_sample)
+
+    logger.info("Successfully connected to all sheets.")
+    return sender_sheet, receiver_sheet, template_sheet
+
+def get_profiles_from_sheet(sheet):
+    data = sheet.get_all_values()
+    return data[1:]  # Exclude header row
+
+def save_profile(sheet, profile_data):
+    new_row = [
+        "Profile",
+        f"PROF_{sheet.row_count}",
+        profile_data['name'],
+        profile_data['email'],
+        profile_data['position'],
+        profile_data['company'],
+        profile_data['context']
+    ]
+    sheet.append_row(new_row)
+
+def delete_profile_from_sheet(sheet, profile_id):
+    cell = sheet.find(profile_id)
+    if cell:
+        sheet.delete_row(cell.row)
+
+def update_profile(sheet, profile_id, profile_data):
+    cell = sheet.find(profile_id)
+    if cell:
+        row = cell.row
+        sheet.update_cell(row, 3, profile_data['name'])
+        sheet.update_cell(row, 4, profile_data['email'])
+        sheet.update_cell(row, 5, profile_data['position'])
+        sheet.update_cell(row, 6, profile_data['company'])
+        sheet.update_cell(row, 7, profile_data['context'])
+
+def get_templates(sheet):
+    data = sheet.get_all_values()
+    return data[1:]  # Exclude header row
+
+def save_template(sheet, template_data):
+    new_row = [
+        "Template",
+        f"TEMP_{sheet.row_count}",
+        template_data['name'],
+        template_data['subject'],
+        template_data['content'],
+        template_data['sender_profile'],
+        template_data['receiver_profile']
+    ]
+    sheet.append_row(new_row)
+
+def delete_template_from_sheet(sheet, template_id):
+    cell = sheet.find(template_id)
+    if cell:
+        sheet.delete_row(cell.row)
+        return True
+    return False
+
+def update_template(sheet, template_id, template_data):
+    cell = sheet.find(template_id)
+    if cell:
+        row = cell.row
+        sheet.update_cell(row, 3, template_data['name'])
+        sheet.update_cell(row, 4, template_data['subject'])
+        sheet.update_cell(row, 5, template_data['content'])
+        sheet.update_cell(row, 6, template_data['sender_profile'])
+        sheet.update_cell(row, 7, template_data['receiver_profile'])

groq_client.py

@@ -0,0 +1,43 @@
+# groq_client.py
+# Filepath: ai-email-assistant/groq_client.py
+# Interfaces with the Groq API for AI-powered responses
+
+import os
+import json
+from groq import Groq
+
+def load_config():
+    try:
+        with open('config.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+config = load_config()
+api_key = config.get('groq_api_key')
+client = Groq(api_key=api_key) if api_key else None
+
+def set_api_key(api_key):
+    global client
+    client = Groq(api_key=api_key)
+
+def get_ai_response(message, system_prompt, context=""):
+    if not client:
+        raise ValueError("Groq API key not set. Please check your config.json file.")
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": message}
+    ]
+    
+    if context:
+        messages.append({"role": "system", "content": context})
+
+    response = client.chat.completions.create(
+        model="mixtral-8x7b-32768",
+        messages=messages,
+        temperature=0.7,
+        max_tokens=1000
+    )
+
+    return response.choices[0].message.content

profile_management.py

@@ -0,0 +1,100 @@
+# profile_management.py
+# Filepath: ai-email-assistant/profile_management.py
+# Handles sender and receiver profile management
+
+import gradio as gr
+from google_sheets_utils import get_profiles_from_sheet, save_profile, delete_profile_from_sheet
+
+def get_profile_summaries(sheet):
+    profiles = get_profiles_from_sheet(sheet)
+    return [profile[2] for profile in profiles]  # Assuming the name is in the third column
+
+def create_profile_management_interface(sheet, profile_type, current_profile):
+    with gr.Group():
+        gr.Markdown(f"## {profile_type} Profile Management")
+        
+        name = gr.Textbox(label="Name")
+        email = gr.Textbox(label="Email")
+        position = gr.Textbox(label="Position")
+        company = gr.Textbox(label="Company")
+        context = gr.Dropdown(["Professional", "Personal"], label="Context")
+        
+        create_btn = gr.Button(f"Create {profile_type} Profile")
+
+        profiles_list = gr.Dataframe(
+            headers=["Type", "ID", "Name", "Email", "Position", "Company", "Context"],
+            label=f"Existing {profile_type} Profiles",
+            value=get_profiles_from_sheet(sheet),
+            interactive=False
+        )
+
+        delete_btn = gr.Button(f"Delete Selected {profile_type} Profile")
+        load_btn = gr.Button(f"Load Selected {profile_type} Profile")
+
+        def create_profile_action():
+            profile_data = {
+                "name": name.value,
+                "email": email.value,
+                "position": position.value,
+                "company": company.value,
+                "context": context.value
+            }
+            save_profile(sheet, profile_data)
+            return get_profiles_from_sheet(sheet)
+
+        def load_profile(evt: gr.SelectData):
+            if evt.value:
+                selected_profile = profiles_list.value[evt.index[0]]
+                current_profile.value = selected_profile[2]  # Set the current profile to the selected name
+                return (
+                    selected_profile[2],  # Name
+                    selected_profile[3],  # Email
+                    selected_profile[4],  # Position
+                    selected_profile[5],  # Company
+                    selected_profile[6],  # Context
+                )
+            return [gr.update() for _ in range(5)]
+
+        def delete_profile(evt: gr.SelectData):
+            if evt.value:
+                profile_id = profiles_list.value[evt.index[0]][1]
+                delete_profile_from_sheet(sheet, profile_id)
+                return get_profiles_from_sheet(sheet)
+            return profiles_list.value
+
+        create_btn.click(create_profile_action, outputs=[profiles_list])
+        load_btn.click(load_profile, outputs=[name, email, position, company, context])
+        delete_btn.click(delete_profile, outputs=[profiles_list])
+
+        refresh_btn = gr.Button(f"Refresh {profile_type} Profiles")
+        refresh_btn.click(lambda: get_profiles_from_sheet(sheet), outputs=[profiles_list])
+
+    return name, email, position, company, context, create_btn, profiles_list, delete_btn, load_btn, refresh_btn
+
+# Implement get_profiles, create_profile, update_profile, delete_profile functions
+def get_profiles(sheet):
+    return get_profiles_from_sheet(sheet)
+
+def create_profile(sheet, name, email, position, company, context):
+    profile_data = {
+        "name": name,
+        "email": email,
+        "position": position,
+        "company": company,
+        "context": context
+    }
+    return save_profile(sheet, profile_data)
+
+def update_profile(sheet, profile_id, name, email, position, company, context):
+    profile_data = {
+        "id": profile_id,
+        "name": name,
+        "email": email,
+        "position": position,
+        "company": company,
+        "context": context
+    }
+    return save_profile(sheet, profile_data)
+
+def delete_profile(sheet, profile_id):
+    return delete_profile_from_sheet(sheet, profile_id)

requirements (2).txt

@@ -0,0 +1,213 @@
+#
+# This file is autogenerated by pip-compile with Python 3.12
+# by the following command:
+#
+#    pip-compile
+#
+aiofiles==23.2.1
+    # via gradio
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.6.0
+    # via
+    #   gradio
+    #   groq
+    #   httpx
+    #   starlette
+cachetools==5.5.0
+    # via google-auth
+certifi==2024.8.30
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.3.2
+    # via requests
+click==8.1.7
+    # via
+    #   duckduckgo-search
+    #   typer
+    #   uvicorn
+colorama==0.4.6
+    # via
+    #   click
+    #   tqdm
+contourpy==1.3.0
+    # via matplotlib
+cycler==0.12.1
+    # via matplotlib
+distro==1.9.0
+    # via groq
+duckduckgo-search==6.2.12
+    # via -r requirements.in
+fastapi==0.115.0
+    # via gradio
+ffmpy==0.4.0
+    # via gradio
+filelock==3.16.1
+    # via huggingface-hub
+fonttools==4.53.1
+    # via matplotlib
+fsspec==2024.9.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+google-auth==2.35.0
+    # via
+    #   -r requirements.in
+    #   google-auth-oauthlib
+    #   gspread
+google-auth-oauthlib==1.2.1
+    # via gspread
+gradio==4.44.0
+    # via -r requirements.in
+gradio-client==1.3.0
+    # via gradio
+groq==0.11.0
+    # via -r requirements.in
+gspread==6.1.2
+    # via -r requirements.in
+h11==0.14.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.5
+    # via httpx
+httpx==0.27.2
+    # via
+    #   gradio
+    #   gradio-client
+    #   groq
+huggingface-hub==0.25.1
+    # via
+    #   gradio
+    #   gradio-client
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+importlib-resources==6.4.5
+    # via gradio
+jinja2==3.1.4
+    # via gradio
+kiwisolver==1.4.7
+    # via matplotlib
+markdown-it-py==3.0.0
+    # via rich
+markupsafe==2.1.5
+    # via
+    #   gradio
+    #   jinja2
+matplotlib==3.9.2
+    # via gradio
+mdurl==0.1.2
+    # via markdown-it-py
+numpy==2.1.1
+    # via
+    #   contourpy
+    #   gradio
+    #   matplotlib
+    #   pandas
+oauthlib==3.2.2
+    # via requests-oauthlib
+orjson==3.10.7
+    # via gradio
+packaging==24.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   matplotlib
+pandas==2.2.3
+    # via gradio
+pillow==10.4.0
+    # via
+    #   gradio
+    #   matplotlib
+primp==0.6.2
+    # via duckduckgo-search
+pyasn1==0.6.1
+    # via
+    #   pyasn1-modules
+    #   rsa
+pyasn1-modules==0.4.1
+    # via google-auth
+pydantic==2.9.2
+    # via
+    #   fastapi
+    #   gradio
+    #   groq
+pydantic-core==2.23.4
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.18.0
+    # via rich
+pyparsing==3.1.4
+    # via matplotlib
+python-dateutil==2.9.0.post0
+    # via
+    #   matplotlib
+    #   pandas
+python-dotenv==1.0.1
+    # via -r requirements.in
+python-multipart==0.0.10
+    # via gradio
+pytz==2024.2
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+requests==2.32.3
+    # via
+    #   huggingface-hub
+    #   requests-oauthlib
+requests-oauthlib==2.0.0
+    # via google-auth-oauthlib
+rich==13.8.1
+    # via typer
+rsa==4.9
+    # via google-auth
+ruff==0.6.7
+    # via gradio
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.16.0
+    # via python-dateutil
+sniffio==1.3.1
+    # via
+    #   anyio
+    #   groq
+    #   httpx
+starlette==0.38.6
+    # via fastapi
+tomlkit==0.12.0
+    # via gradio
+tqdm==4.66.5
+    # via huggingface-hub
+typer==0.12.5
+    # via gradio
+typing-extensions==4.12.2
+    # via
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   groq
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   typer
+tzdata==2024.1
+    # via pandas
+urllib3==2.2.3
+    # via
+    #   gradio
+    #   requests
+uvicorn==0.30.6
+    # via gradio
+websockets==12.0
+    # via gradio-client

system_prompt.txt

@@ -0,0 +1,65 @@
+You are an AI-driven email assistant designed to help users generate and refine personalized emails for various scenarios, including professional and personal contexts. Your goal is to gather necessary information through natural conversation and then create tailored emails. Adapt your role based on the email type, switching between casual assistant and professional content generator as needed. Follow these guidelines:
+1. Initial Interaction:
+   - Greet the user warmly and briefly explain your purpose.
+   - Ask an open-ended question about the type of email they need help with.
+   - Example: "Hello! I'm here to help you craft the perfect email. What kind of email are you looking to write today?"
+2. Information Gathering:
+   - Based on the user's response, ask relevant follow-up questions to gather necessary details.
+   - Adapt your questions to various email scenarios, including:
+     a) Professional emails: sales pitch, follow-up, introduction, product launch, partnership proposal
+     b) Personal emails: friendly correspondence, family updates
+     c) Transactional emails: customer support, shipping information, order confirmation
+     d) Formal communications: complaint to a company, job application, resignation letter
+   - Keep questions concise and conversational.
+   - For professional emails, gather additional relevant information:
+     a) Sender's details: name, job title, company, industry
+     b) Recipient's details: name, job title, company (if known)
+     c) Specific purpose: e.g., introducing a new product, following up on a sales call
+     d) Key points: e.g., 3 main features of a product, unique selling propositions
+     e) Any prior communication or context
+     f) Call-to-action or desired outcome
+   - For personal or transactional emails, adjust questions accordingly to gather relevant details.
+3. Background Checklist:
+   - Maintain an internal checklist of essential information for different email types.
+   - Discreetly check off items as you gather information.
+   - If crucial information is missing, naturally work it into the conversation.
+4. Information Confirmation:
+   - Summarize the gathered information concisely.
+   - Ask if anything is missing or needs changing.
+5. Role Adaptation:
+   - Based on the email type, adapt your role:
+     a) For professional emails: Take on the role of a professional content generator. Use industry-specific language, maintain a formal tone, and focus on creating compelling, persuasive content.
+     b) For personal emails: Maintain a friendly, conversational tone and focus on personal details and emotional context.
+     c) For transactional emails: Adopt a clear, concise, and informative tone, ensuring all necessary details are included.
+6. Email Generation:
+   - Create a personalized draft based on the confirmed information and your adapted role.
+   - Ensure the email is appropriate for the specific scenario and recipient.
+   - For professional emails, incorporate:
+     a) A strong, attention-grabbing opening
+     b) Clear presentation of key points or features
+     c) Relevant data or statistics to support your message
+     d) A clear call-to-action
+   - For personal or transactional emails, focus on clarity, warmth, or informativeness as appropriate.
+7. Refinement and Feedback:
+   - Present the draft to the user.
+   - Ask for overall impressions and any specific areas needing adjustment.
+   - Offer to make changes based on feedback.
+8. Iterative Improvement:
+   - Make requested adjustments promptly.
+   - Continue refining until the user is satisfied.
+9. Final Touches:
+   - Suggest additions like professional signatures, legal disclaimers, or attachment reminders if appropriate.
+   - Perform a final check for clarity, grammar, coherence, and appropriateness for the intended audience.
+10. Completion and Next Steps:
+    - Present the final version.
+    - Offer to save as a template or start a new email if needed.
+11. Adaptability:
+    - Remember user preferences within the session.
+    - Adjust your approach based on the user's communication style and the email context.
+12. Clarity and Error Handling:
+    - If confused, ask for clarification naturally.
+    - Guide users clearly if they seem unsure about the process.
+13. Privacy Reminder:
+    - Tactfully remind users not to share sensitive personal information.
+    - Mention that information isn't stored between sessions.
+Always aim for clear, relevant, and engaging responses. Adapt your personality and language to match the user's tone and the email's purpose. Your goal is to make the email creation process smooth, efficient, and tailored to each unique situation, whether it's a high-stakes professional communication or a casual personal message.

web_search.py

@@ -0,0 +1,13 @@
+# web_search.py
+# Filepath: ai-email-assistant/web_search.py
+# Implements web search functionality
+
+from duckduckgo_search import DDGS
+
+def search_web(query, num_results=5):
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=num_results))
+        return [f"{r['title']}: {r['body']}" for r in results]
+    except Exception as e:
+        return [f"Error performing web search: {str(e)}"]