Update app.py

app.py

@@ -7,7 +7,7 @@ proxycurl_api_key = os.getenv("PROXYCURL_API_KEY")  # Proxycurl API key
 groq_api_key = os.getenv("GROQ_CLOUD_API_KEY")  # Groq Cloud API key
 firecrawl_api_key = os.getenv("FIRECRAWL_API_KEY")  # Firecrawl API key
 
-class EmailAgent:
+class AutonomousEmailAgent:
     def __init__(self, linkedin_url, company_name, role, word_limit, user_name, email, phone, linkedin):
         self.linkedin_url = linkedin_url
         self.company_name = company_name
@@ -23,38 +23,33 @@ class EmailAgent:
         self.company_info = None
         self.role_description = None
 
-    # Use the LLM to reason and reflect on the provided data
-    def reason_with_llm(self):
-        print("Reasoning: Using LLM to reason about available data...")
+    # 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...")
         
-        # LLM reasoning prompt that evaluates the current data and reflects on next actions
+        # LLM reasoning prompt that evaluates the current data and issues actions autonomously
         reasoning_prompt = f"""
-        You are a reasoning agent tasked with generating a job application email. Here's what we have:
+        You are an autonomous agent responsible for generating a job application email.
         
-        1. Candidate's LinkedIn profile URL: {self.linkedin_url}
-        2. Company Name: {self.company_name}
-        3. Role: {self.role}
-        4. Word Limit: {self.word_limit}
-        5. Candidate's Name: {self.user_name}
-        6. Candidate's Email: {self.email}
-        7. Candidate's Phone: {self.phone}
-        8. Candidate's LinkedIn: {self.linkedin}
-
-        Candidate's Bio: {self.bio}
-        Candidate's Skills: {', '.join(self.skills)}
-        Candidate's Experiences: {', '.join([exp['title'] for exp in self.experiences])}
-
-        Company Information: {self.company_info}
-        Role Description: {self.role_description}
-
-        Evaluate the completeness of the data. If some key data is missing, determine whether we should:
-        - Scrape for more data (e.g., company info, role descriptions).
-        - Proceed with the available information and generate the email using default logic.
-
-        Reflect on whether we need more data or if the current information is sufficient to proceed.
-        """
+        Here's the current data:
+        
+        - LinkedIn profile: {self.linkedin_url}
+        - Company Name: {self.company_name}
+        - Role: {self.role}
+        - Candidate's Bio: {self.bio}
+        - Candidate's Skills: {', '.join(self.skills)}
+        - Candidate's Experiences: {', '.join([exp['title'] for exp in self.experiences])}
+        - Company Information: {self.company_info}
+        - Role Description: {self.role_description}
         
-        # Send this reasoning prompt to the LLM
+        Based on this data, decide if it is sufficient to generate the email. If some information is missing or insufficient:
+        - Decide whether to scrape the company's website for more information or use a fallback.
+        - If the scraping fails, decide what next steps to take.
+
+        Once the information is complete, proceed to generate the email. After generating the email, reflect on whether the content aligns with the role and company and whether any improvements are needed.
+        """
+
+        # Send the reasoning prompt to the LLM
         url = "https://api.groq.com/openai/v1/chat/completions"
         headers = {
             "Authorization": f"Bearer {groq_api_key}",
@@ -70,12 +65,30 @@ class EmailAgent:
         if response.status_code == 200:
             reasoning_output = response.json()["choices"][0]["message"]["content"].strip()
             print("LLM Reasoning Output:", reasoning_output)
-            return reasoning_output
+            
+            # Now the LLM takes action based on the reflection
+            return self.act_on_llm_instructions(reasoning_output)
         else:
             print(f"Error: {response.status_code}, {response.text}")
             return "Error: Unable to complete reasoning."
 
-    # Action: Fetch LinkedIn data via Proxycurl (acting based on reasoning)
+    # Function to act on the LLM's instructions
+    def act_on_llm_instructions(self, reasoning_output):
+        # Parse the LLM's instructions (assume it's structured with action steps)
+        if "scrape the company's website" in reasoning_output:
+            # Action: Scrape the company's website for more information
+            self.fetch_company_info_with_firecrawl()
+            # Reflect again by invoking the LLM to reassess
+            return self.autonomous_reasoning()
+
+        elif "generate the email" in reasoning_output:
+            # Action: Proceed to generate the email
+            return self.generate_email()
+
+        else:
+            return "Error: Unrecognized instruction from LLM."
+
+    # Action: Fetch LinkedIn data via Proxycurl
     def fetch_linkedin_data(self):
         if not self.linkedin_url:
             print("Action: No LinkedIn URL provided, using default bio.")
@@ -121,11 +134,10 @@ class EmailAgent:
                 print(f"Error: Unable to fetch company info via Firecrawl. Using default info.")
                 self.company_info = "A leading company in its field."
 
-    # Final Action: Generate the email using Groq Cloud LLM based on gathered data
+    # Final Action: Generate the email using Groq Cloud LLM
     def generate_email(self):
         print("Action: Generating the email with the gathered information.")
         
-        # Use the LinkedIn profile link dynamically in the body
         linkedin_text = f"Please find my LinkedIn profile at {self.linkedin}" if self.linkedin else ""
 
         # Dynamic LLM prompt
@@ -175,13 +187,9 @@ class EmailAgent:
 
     # Main loop following ReAct pattern
     def run(self):
-        reasoning_output = self.reason_with_llm()  # LLM performs reasoning and reflection
-        print("LLM Reflection:", reasoning_output)
-
         self.fetch_linkedin_data()  # Fetch LinkedIn data
-        self.fetch_company_info_with_firecrawl()  # Fetch company data using Firecrawl
-        
-        return self.generate_email()  # Final action: generate email
+        # Let LLM autonomously decide and act
+        return self.autonomous_reasoning()  
 
 # Define the Gradio interface and the main app logic
 def gradio_ui():
@@ -197,3 +205,24 @@ def gradio_ui():
     # 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],
+        outputs=[email_output],
+        title="Email Writing AI Agent with ReAct",
+        description="Generate a professional email for a job application using LinkedIn data, company info, and role description.",
+        allow_flagging="never"
+    )
+    
+    # Launch the Gradio app
+    demo.launch()
+
+# Start the Gradio app when running the script
+if __name__ == "__main__":
+    gradio_ui()