Update app.py

app.py

@@ -1,5 +1,5 @@
-import requests
 import gradio as gr
+import requests
 import os
 
 # Load API keys securely from environment variables
@@ -23,15 +23,57 @@ class EmailAgent:
         self.company_info = None
         self.role_description = None
 
-    # Reason: Decide what information is needed
-    def reason_about_data(self):
-        print("Reasoning: Deciding what data we need...")
-        if not self.linkedin_url:
-            print("Warning: LinkedIn URL missing. Proceeding with default bio.")
-        if not self.company_name:
-            print("Warning: Company name missing. Proceeding with default company info.")
-        if not self.role:
-            print("Warning: Role missing. We will use general logic for the role.")
+    # 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...")
+        
+        # LLM reasoning prompt that evaluates the current data and reflects on next actions
+        reasoning_prompt = f"""
+        You are a reasoning agent tasked with generating a job application email. Here's what we have:
+        
+        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.
+        """
+        
+        # Send this reasoning prompt to the LLM
+        url = "https://api.groq.com/openai/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {groq_api_key}",
+            "Content-Type": "application/json",
+        }
+        
+        data = {
+            "messages": [{"role": "user", "content": reasoning_prompt}],
+            "model": "llama3-8b-8192"
+        }
+        
+        response = requests.post(url, headers=headers, json=data)
+        if response.status_code == 200:
+            reasoning_output = response.json()["choices"][0]["message"]["content"].strip()
+            print("LLM Reasoning Output:", reasoning_output)
+            return 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)
     def fetch_linkedin_data(self):
@@ -79,13 +121,6 @@ class EmailAgent:
                 print(f"Error: Unable to fetch company info via Firecrawl. Using default info.")
                 self.company_info = "A leading company in its field."
 
-    # Reflection: Check if we have enough data to generate the email
-    def reflect_on_data(self):
-        print("Reflection: Do we have enough data?")
-        if not self.bio or not self.skills or not self.company_info:
-            print("Warning: Some critical information is missing. Proceeding with default values.")
-        return True
-
     # Final Action: Generate the email using Groq Cloud LLM based on gathered data
     def generate_email(self):
         print("Action: Generating the email with the gathered information.")
@@ -133,14 +168,13 @@ class EmailAgent:
 
     # Main loop following ReAct pattern
     def run(self):
-        self.reason_about_data()  # Reasoning step
+        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
-        # Reflect on whether the data is sufficient
-        if self.reflect_on_data():
-            return self.generate_email()  # Final action: generate email
-        else:
-            return "Error: Not enough data to generate the email."
+        
+        return self.generate_email()  # Final action: generate email
 
 # Define the Gradio interface and the main app logic
 def gradio_ui():