updated the app and requirments

app.py

@@ -1,11 +1,9 @@
-import gradio as gr
-from transformers import AutoTokenizer, AutoModelForCausalLM, LlamaConfig
 import os
-from dotenv import load_dotenv
+import gradio as gr
 import logging
 import sys
-from huggingface_hub import login, HfApi
-import torch
+import requests
+from dotenv import load_dotenv
 
 # Load environment variables
 load_dotenv()
@@ -13,227 +11,127 @@ load_dotenv()
 # Setup logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s', stream=sys.stdout)
 
-# Authenticate with Hugging Face
-hf_token = os.environ.get("HUGGINGFACE_TOKEN")
-model_name = "meta-llama/Llama-3.1-8B"
+# Retrieve the Groq API key from environment variables
+groq_api_key = os.getenv("GROQ_TOKEN")
 
-if hf_token:
-    try:
-        login(token=hf_token)
-        api = HfApi()
-        api.whoami()
-        logging.info("Successfully logged in to Hugging Face")
-    except Exception as e:
-        logging.error(f"Error authenticating with Hugging Face: {str(e)}")
-        logging.warning("Proceeding without authentication. This may limit access to certain models.")
-else:
-    logging.warning("HUGGINGFACE_TOKEN not found in environment variables. Proceeding without authentication.")
-
-# Load the model and tokenizer
-try:
-    logging.info(f"Attempting to load tokenizer for {model_name}")
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    logging.info("Tokenizer loaded successfully")
-    
-    logging.info(f"Attempting to load model {model_name}")
-    model = AutoModelForCausalLM.from_pretrained(model_name)
-    logging.info("Model loaded successfully")
-    
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
-        model.config.pad_token_id = model.config.eos_token_id
-    
-    logging.info(f"Successfully loaded {model_name}")
-except Exception as e:
-    logging.error(f"Error loading {model_name}: {str(e)}")
-    raise
-
-MAX_TOTAL_TOKENS = 2048  # Adjusted to Llama model's token limit
-MAX_INPUT_TOKENS = 1600  # 1600 tokens for input, leaving room for generated output
-CONTEXT_RATIO = 0.6  # Adjusted for summarization
-
-def truncate_to_token_limit(text, max_tokens):
-    tokens = tokenizer.encode(text)
-    if len(tokens) > max_tokens:
-        tokens = tokens[:max_tokens]
-    return tokenizer.decode(tokens, skip_special_tokens=True)
-
-def summarize_text(text, max_tokens):
-    if len(tokenizer.encode(text)) <= max_tokens:
-        return text, None
-
-    summarization_prompt = f"""
-    Summarize the following text concisely, preserving the key points:
-
-    {text}
-
-    Ensure the summary is under {max_tokens} tokens.
-    """
-    
-    try:
-        inputs = tokenizer(summarization_prompt, return_tensors="pt", padding=True, truncation=True, max_length=int(MAX_INPUT_TOKENS * CONTEXT_RATIO))
-        
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        model.to(device)
-        inputs = {k: v.to(device) for k, v in inputs.items()}
-        
-        with torch.no_grad():
-            summary_outputs = model.generate(
-                **inputs, 
-                max_new_tokens=max_tokens,
-                num_return_sequences=1,
-                temperature=0.7,
-                top_k=50,
-                top_p=0.95,
-                do_sample=True
-            )
-        
-        summary = tokenizer.decode(summary_outputs[0], skip_special_tokens=True)
-        summary = summary.replace(summarization_prompt, "").strip()
-        
-        warning = "Input was summarized to fit the token limit. Some details may be omitted."
-        return summary, warning
-    except Exception as e:
-        logging.error(f"Error during summarization: {str(e)}")
-        return text[:max_tokens] + "...", "Error in summarization. Text was truncated."
-
-def generate_prompt(recipient_name, recipient_role, industry, details):
-    details, warning = summarize_text(details, MAX_INPUT_TOKENS // 2)
-    
-    prompt_generation_input = f"""
-    Create a detailed prompt for writing a professional email based on the following information:
-    - Recipient: {recipient_name}, a {recipient_role} in the {industry} industry
-    - Purpose: {details}
-
-    Include:
-    1. Greeting
-    2. Main email points
-    3. Suggested closing
-    4. Tone (e.g., formal, friendly)
-    5. Industry-relevant phrases or terms
-    """
-
-    prompt_generation_input = truncate_to_token_limit(prompt_generation_input, MAX_INPUT_TOKENS)
-    
-    try:
-        inputs = tokenizer(prompt_generation_input, return_tensors="pt", padding=True, truncation=True, max_length=MAX_INPUT_TOKENS)
-        
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        model.to(device)
-        inputs = {k: v.to(device) for k, v in inputs.items()}
-        
-        with torch.no_grad():
-            prompt_outputs = model.generate(
-                **inputs, 
-                max_new_tokens=200,
-                num_return_sequences=1,
-                temperature=0.7,
-                top_k=50,
-                top_p=0.95,
-                do_sample=True
-            )
-        
-        generated_prompt = tokenizer.decode(prompt_outputs[0], skip_special_tokens=True)
-        return generated_prompt.replace(prompt_generation_input, "").strip(), warning
+# Define the model name for Groq API
+model_name = "llama-3.1-8b-instant"
 
-    except Exception as e:
-        logging.error(f"Error generating prompt: {str(e)}")
-        return f"Error generating prompt: {str(e)}", None
-
-def generate_email_body(prompt):
-    # Concise prompt without instruction language
-    email_generation_input = f"""
-    {prompt}
-    """
-    
-    # Limit input to token constraints
-    email_generation_input = truncate_to_token_limit(email_generation_input, MAX_INPUT_TOKENS)
-    
+# Define maximum tokens allowed for context within the prompt
+MAX_CONTEXT_TOKENS = 750
+
+def complete_task(val, instruction, token_limit, temperature=0.2):
     try:
-        inputs = tokenizer(email_generation_input, return_tensors="pt", padding=True, truncation=True, max_length=MAX_INPUT_TOKENS)
+        prompt = f"{val}\n{instruction}"
         
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        model.to(device)
-        inputs = {k: v.to(device) for k, v in inputs.items()}
+        headers = {
+            "Authorization": f"Bearer {groq_api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "messages": [{"role": "user", "content": prompt}],
+            "model": model_name,
+            "max_tokens": token_limit,
+            "temperature": temperature
+        }
+
+        response = requests.post("https://api.groq.com/openai/v1/chat/completions", json=payload, headers=headers)
+        response_data = response.json()
         
-        with torch.no_grad():
-            email_outputs = model.generate(
-                **inputs, 
-                max_new_tokens=300,
-                num_return_sequences=1,
-                temperature=0.5,  # Lower temperature for more focused output
-                top_k=50,
-                top_p=0.95,
-                do_sample=False  # Deterministic output
-            )
-        
-        # Decode and return only the email body
-        email_body = tokenizer.decode(email_outputs[0], skip_special_tokens=True).strip()
-        
-        return email_body
-
+        if response.status_code == 200 and "choices" in response_data:
+            answer = response_data["choices"][0]["message"]["content"]
+            logging.info(f"Model output:\n{answer}")
+            return answer.strip()  # Take the full response without truncation
+        else:
+            error_message = response_data.get("error", "No response generated.")
+            logging.warning(f"Model did not generate usable content: {error_message}")
+            return "No response generated."
     except Exception as e:
-        logging.error(f"Error generating email body: {str(e)}")
-        return f"Error generating email body: {str(e)}"
-
-def generate_email(recipient_name, recipient_email, industry, recipient_role, details):
-    try:
-        # Clear, minimal prompt to keep focus on main content generation
-        generated_prompt = f"I am reaching out to discuss {details} in the context of {industry} and how it impacts your role as a {recipient_role}."
-
-        # Generate the email body
-        email_body = generate_email_body(generated_prompt)
-        if email_body.startswith("Error"):
-            return email_body
-
-        # Remove duplicate greetings and signatures if they appear
-        email_body_lines = email_body.splitlines()
-        unique_lines = []
-        for line in email_body_lines:
-            if line.strip() and line not in unique_lines:
-                unique_lines.append(line)
-        email_body = "\n".join(unique_lines)
-
-        # Assemble the final email content
-        final_output = f"""
-Subject: {details.split()[0].capitalize()} Proposal
-
-Dear {recipient_name},
-
-{email_body}
-
-Sincerely,  
-Your Name  
-Your Title  
-Your Company  
-Your Email  
-Your Phone Number  
-Your Address  
-Your Website  
-Your Social Media Profiles
-"""
-        logging.info(f"Final email content:\n{final_output}")
-        return final_output
-
-    except Exception as e:
-        logging.error(f"Error in generate_email: {str(e)}")
-        return f"Error generating email: {str(e)}"
-
-
-
+        error_message = f"An error occurred: {str(e)}"
+        logging.error(error_message)
+        return error_message
+
+def generate_subject(context):
+    subject_prompt = "Provide only one concise subject line for an email about the following context."
+    subject_line = complete_task(context, subject_prompt, token_limit=25, temperature=0.5)
+    if not subject_line or len(subject_line.split()) > 10:
+        logging.warning("Generated subject line is too long or empty. Using default subject.")
+        return "Request for Promotion Based on Project Achievements"
+    return subject_line
+
+def generate_greeting(name):
+    greeting_prompt = f"Provide a single, formal greeting for an email addressed to {name}. No alternatives."
+    greeting = complete_task(name, greeting_prompt, token_limit=20, temperature=0.3)
+    return greeting if greeting else f"Dear {name},"
+
+def generate_body(context, tone):
+    body_prompt = f"Write a brief and direct {tone} email body based on the following context: {context}"
+    body = complete_task(context, body_prompt, token_limit=500, temperature=0.7)
+    return body if body else "I am reaching out regarding my recent achievements and contributions to request a promotion."
+
+def generate_closing():
+    closing_prompt = "Provide a single professional closing statement for an email. No alternatives."
+    closing = complete_task("", closing_prompt, token_limit=30, temperature=0.3)
+    return closing if closing else "Best regards,\n[Your Name]"
+
+def refine_email(full_email):
+    cohesion_prompt = "Ensure the following email is clear, professional, and follows standard email format. Remove any extra instructions or notes."
+    refined_email = complete_task(full_email, cohesion_prompt, token_limit=500, temperature=0.5)
+    return refined_email if refined_email else full_email
+
+def generate_email(name, recipient_email, industry, recipient_role, context, tone_dropdown, custom_tone):
+    logging.info("Starting section-wise email generation process with Groq API")
+
+    tone = custom_tone.strip() if custom_tone else tone_dropdown or "formal"
+    logging.info(f"Selected tone: {tone}")
+
+    # Generate each section with a fallback if empty
+    subject = generate_subject(context)
+    if not subject or subject.strip() == "":
+        subject = "Request for Promotion Discussion"
+
+    greeting = generate_greeting(name)
+    if not greeting or greeting.strip() == "":
+        greeting = f"Dear {name},"
+
+    body = generate_body(context, tone)
+    if not body or body.strip() == "":
+        body = "I am writing to discuss my recent achievements and contributions in hopes of discussing a promotion."
+
+    closing = generate_closing()
+    if not closing or closing.strip() == "":
+        closing = "Best regards,\n[Your Name]"
+
+    # Combine sections into a full email
+    full_email = f"Subject: {subject}\n\n{greeting}\n\n{body}\n\n{closing}"
+    logging.info(f"Constructed email before refinement:\n{full_email}")
+
+    # Attempt final refinement
+    refined_email = refine_email(full_email)
+    if "No response generated" in refined_email or len(refined_email.strip()) == 0:
+        logging.warning("Refinement failed to produce complete content. Returning unrefined email.")
+        return full_email
+
+    return refined_email
+
+# Gradio Interface
 iface = gr.Interface(
     fn=generate_email,
     inputs=[
         gr.Textbox(lines=1, label="Recipient Name"),
         gr.Textbox(lines=1, label="Recipient Email"),
-        gr.Textbox(lines=1, label="Industry (e.g., Technology, Healthcare)"),
-        gr.Textbox(lines=1, label="Recipient Role (e.g., Manager, Director)"),
-        gr.Textbox(lines=5, label="Personal/Company Details"),
+        gr.Textbox(lines=1, label="Industry"),
+        gr.Textbox(lines=1, label="Recipient Role"),
+        gr.Textbox(lines=5, label="Context of Email"),
+        gr.Dropdown(choices=["formal", "friendly", "persuasive"], label="Tone", value="formal"),
+        gr.Textbox(lines=1, label="Custom Tone (optional)")
     ],
-    outputs=gr.Textbox(lines=10, label="Generated Email or Error Message"),
-    title="EmailGenie: AI-Powered Email Generator",
-    description="Automate the creation of personalized emails. Enter details to generate tailored emails."
+    outputs=gr.Textbox(lines=10, label="Generated Email"),
+    title="AI Email Generator",
+    description="Generate personalized emails based on input details.",
 )
 
 if __name__ == '__main__':
+    logging.info("Launching Gradio interface")
     iface.launch()

requirements.txt

@@ -1,5 +1,3 @@
 gradio==3.50.2
-transformers==4.36.2
-torch==2.1.2
-huggingface_hub==0.20.2
+requests==2.31.0
 python-dotenv==1.0.0