Update app.py

app.py

@@ -1,13 +1,7 @@
 import gradio as gr
 import requests
 import os
-from openai import OpenAI
-
-# Initialize the Groq Cloud LLM client
-client = OpenAI(
-    base_url="https://api.groq.com/openai/v1",
-    api_key=os.getenv("GROQ_API_KEY")  # Use your Groq Cloud API key
-)
+import json
 
 class AutonomousEmailAgent:
     def __init__(self, linkedin_url, company_name, role, word_limit, user_name, email, phone, linkedin):
@@ -24,13 +18,12 @@ class AutonomousEmailAgent:
         self.experiences = []
         self.company_info = None
         self.role_description = None
-        self.company_url = None  # Add company URL for scraping
+        self.company_url = None
 
     # Reason and Act via LLM: Let the LLM control reasoning and actions dynamically
     def autonomous_reasoning(self):
         print("Autonomous Reasoning: Letting the LLM fully reason and act on available data...")
         
-        # Modify LLM reasoning prompt to ask for clear, structured instructions
         reasoning_prompt = f"""
         You are an autonomous agent responsible for generating a job application email.
         
@@ -52,23 +45,30 @@ class AutonomousEmailAgent:
         After generating the email, reflect on whether the content aligns with the role and company and whether any improvements are needed. Respond clearly with one of the above options.
         """
         
-        # Send the reasoning prompt to the Groq Cloud LLM
-        completion = client.chat.completions.create(
-            model="llama3-8b-8192",  # Adjust model if necessary
-            messages=[{"role": "user", "content": reasoning_prompt}],
-            temperature=0.5,
-            top_p=1,
-            max_tokens=1024,
-            stream=True
-        )
-
-        reasoning_output = ""
-        for chunk in completion:
-            if chunk.choices[0].delta.content is not None:
-                print(chunk.choices[0].delta.content, end="")
-                reasoning_output += chunk.choices[0].delta.content
-
-        return self.act_on_llm_instructions(reasoning_output)
+        return self.send_request_to_llm(reasoning_prompt)
+
+    # Send request to Groq Cloud LLM
+    def send_request_to_llm(self, prompt):
+        print("Sending request to Groq Cloud LLM...")
+        api_key = os.getenv("GROQ_API_KEY")
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "model": "llama-3.1-70b-versatile",  # Updated model name
+            "messages": [{"role": "user", "content": prompt}]
+        }
+        response = requests.post("https://api.groq.com/openai/v1/chat/completions", headers=headers, json=data)
+        
+        if response.status_code == 200:
+            result = response.json()
+            content = "".join([chunk.get("choices", [{}])[0].get("delta", {}).get("content", "") for chunk in result])
+            print(content)
+            return self.act_on_llm_instructions(content)
+        else:
+            print(f"Error: Unable to connect to Groq Cloud LLM. Status Code: {response.status_code}")
+            return "Error: Unable to generate response."
 
     # Function to act on the LLM's structured instructions
     def act_on_llm_instructions(self, reasoning_output):
@@ -97,9 +97,8 @@ class AutonomousEmailAgent:
 
     # Fetch company URL using SERP API
     def fetch_company_url(self):
-        serp_api_key = os.getenv("SERP_API_KEY")  # Fetch the SERP API key from the environment
+        serp_api_key = os.getenv("SERP_API_KEY")
         print(f"Fetching company URL for {self.company_name} using SERP API...")
-        
         serp_url = f"https://serpapi.com/search.json?q={self.company_name}&api_key={serp_api_key}&num=1"
         response = requests.get(serp_url)
         
@@ -112,11 +111,11 @@ class AutonomousEmailAgent:
                 print("No URL found for the company via SERP API.")
                 self.company_url = None
         else:
-            print(f"Error fetching company URL: {response.status_code}. Retrying with fallback or alternative...")
+            print(f"Error fetching company URL: {response.status_code}")
 
     # Fetch LinkedIn data via Proxycurl
     def fetch_linkedin_data(self):
-        proxycurl_api_key = os.getenv("PROXYCURL_API_KEY")  # Fetch API key from environment
+        proxycurl_api_key = os.getenv("PROXYCURL_API_KEY")
         if not self.linkedin_url:
             print("Action: No LinkedIn URL provided, using default bio.")
             self.bio = "A professional with diverse experience."
@@ -140,15 +139,11 @@ class AutonomousEmailAgent:
 
     # Fetch company information via Firecrawl API using company URL
     def fetch_company_info_with_firecrawl(self, company_url):
-        firecrawl_api_key = os.getenv("FIRECRAWL_API_KEY")  # Fetch the Firecrawl API key from the environment
+        firecrawl_api_key = os.getenv("FIRECRAWL_API_KEY")
         print(f"Fetching company info for {company_url} using Firecrawl.")
-        
         headers = {"Authorization": f"Bearer {firecrawl_api_key}"}
         firecrawl_url = "https://api.firecrawl.dev/v1/scrape"
-        data = {
-            "url": company_url,
-            "patterns": ["description", "about", "careers", "company overview"]
-        }
+        data = {"url": company_url, "patterns": ["description", "about", "careers", "company overview"]}
         
         response = requests.post(firecrawl_url, json=data, headers=headers)
         if response.status_code == 200:
@@ -156,10 +151,10 @@ class AutonomousEmailAgent:
             self.company_info = firecrawl_data.get("description", "No detailed company info available.")
             print(f"Company info fetched: {self.company_info}")
         else:
-            print(f"Error: Unable to fetch company info via Firecrawl. Retrying or using fallback...")
+            print(f"Error: Unable to fetch company info via Firecrawl. Status code: {response.status_code}")
             self.company_info = "A leading company in its field."
 
-    # Final Action: Generate the email using Groq Cloud LLM with "Start with Why" framework
+    # Final Action: Generate the email using Groq Cloud LLM
     def generate_email(self):
         print("Action: Generating the email using Groq Cloud LLM with the gathered information.")
 
@@ -167,51 +162,34 @@ class AutonomousEmailAgent:
         Write a professional job application email applying for the {self.role} position at {self.company_name}.
 
         The email should follow the "Start with Why" approach:
-        1. **Why**: Begin with the candidate’s **purpose** or **belief**—why they are passionate about this role and the company. What motivates them to apply for this role? Connect their personal mission to the company's values, mission, or goals.
-        2. **How**: Explain how the candidate’s skills, experience, and approach align with both their "why" and the company’s mission. This should show how they are uniquely qualified to contribute to the company’s success.
-        3. **What**: Provide concrete examples of the candidate’s past achievements that support their qualifications for this role. These examples should demonstrate the candidate’s ability to succeed based on their skills and experience.
-        4. **Call to Action**: End with a polite request for a meeting or further discussion to explore how the candidate can contribute to the company's success.
-
-        Use the following information to craft the email:
-        - The candidate’s LinkedIn bio: {self.bio}.
-        - The candidate’s most relevant skills: {', '.join(self.skills)}.
-        - The candidate’s professional experience: {', '.join([exp['title'] for exp in self.experiences])}.
-        - Company information: {self.company_info}.
-        - Role description: {self.role_description}.
-
-        End the email with this signature:
+        1. **Why**: Explain why the candidate is passionate about this role and company.
+        2. **How**: Highlight the candidate’s skills and experiences.
+        3. **What**: Provide examples of past achievements.
+        4. **Call to Action**: Request a meeting or discussion.
+
+        - LinkedIn bio: {self.bio}
+        - Skills: {', '.join(self.skills)}
+        - Experience: {', '.join([exp['title'] for exp in self.experiences])}
+        - Company information: {self.company_info}
+
+        Signature:
         Best regards,
         {self.user_name}
         Email: {self.email}
         Phone: {self.phone}
         LinkedIn: {self.linkedin}
 
-        The email should not exceed {self.word_limit} words.
+        Limit the email to {self.word_limit} words.
         """
 
-        completion = client.chat.completions.create(
-            model="llama3-8b-8192",
-            messages=[{"role": "user", "content": prompt}],
-            temperature=0.5,
-            top_p=1,
-            max_tokens=1024,
-            stream=True
-        )
-
-        generated_email = ""
-        for chunk in completion:
-            if chunk.choices[0].delta.content is not None:
-                print(chunk.choices[0].delta.content, end="")
-                generated_email += chunk.choices[0].delta.content
-
-        return generated_email
+        return self.send_request_to_llm(prompt)
 
     # Main loop following ReAct pattern
     def run(self):
-        self.fetch_linkedin_data()  # Fetch LinkedIn data
-        return self.autonomous_reasoning()  # Let the LLM autonomously decide and act
+        self.fetch_linkedin_data()
+        return self.autonomous_reasoning()
 
-# Define the Gradio interface and the main app logic
+# Gradio UI setup remains the same
 def gradio_ui():
     # Input fields
     name_input = gr.Textbox(label="Your Name", placeholder="Enter your name")
@@ -222,15 +200,12 @@ def gradio_ui():
     linkedin_input = gr.Textbox(label="Your LinkedIn URL", placeholder="Enter your LinkedIn profile URL")
     word_limit_slider = gr.Slider(minimum=50, maximum=300, step=10, label="Email Word Limit", value=150)
     
-    # Output field
     email_output = gr.Textbox(label="Generated Email", placeholder="Your generated email will appear here", lines=10)
 
-    # Function to create and run the email agent
     def create_email(name, company_name, role, email, phone, linkedin_url, word_limit):
         agent = AutonomousEmailAgent(linkedin_url, company_name, role, word_limit, name, email, phone, linkedin_url)
         return agent.run()
 
-    # Gradio interface
     demo = gr.Interface(
         fn=create_email,
         inputs=[name_input, company_input, role_input, email_input, phone_input, linkedin_input, word_limit_slider],
@@ -240,9 +215,7 @@ def gradio_ui():
         allow_flagging="never"
     )
     
-    # Launch the Gradio app
     demo.launch()
 
-# Start the Gradio app when running the script
 if __name__ == "__main__":
     gradio_ui()