Update app.py

app.py

@@ -1,12 +1,13 @@
 import gradio as gr
 import requests
 import os
+from openai import OpenAI
 
-# Load API keys securely from environment variables
-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
-serp_api_key = os.getenv("SERP_API_KEY")  # SERP API key for fetching company URL
+# Initialize the NVIDIA LLM client
+client = OpenAI(
+    base_url="https://integrate.api.nvidia.com/v1",
+    api_key=os.getenv("NVIDIA_API_KEY")  # Use your NVIDIA API key
+)
 
 class AutonomousEmailAgent:
     def __init__(self, linkedin_url, company_name, role, word_limit, user_name, email, phone, linkedin):
@@ -52,47 +53,37 @@ class AutonomousEmailAgent:
         """
         
         # Send the 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)
-            
-            # 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."
+        completion = client.chat.completions.create(
+            model="nvidia/llama-3.1-nemotron-70b-instruct",
+            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)
 
     # Function to act on the LLM's structured instructions
     def act_on_llm_instructions(self, reasoning_output):
-        # Convert the output to lowercase and trim whitespace for easier parsing
         instruction = reasoning_output.lower().strip()
 
         if "scrape" in instruction:
-            # Action: Fetch company URL via SERP API before scraping
             self.fetch_company_url()
             if self.company_url:
                 self.fetch_company_info_with_firecrawl(self.company_url)
-            # Reflect again by invoking the LLM to reassess
             return self.autonomous_reasoning()
 
         elif "generate_email" in instruction:
-            # Action: Proceed to generate the email
             return self.generate_email()
 
         elif "fallback" in instruction:
-            # Action: Use fallback logic or default values
             print("Action: Using fallback values for missing data.")
             if not self.company_info:
                 self.company_info = "A leading company in its field."
@@ -101,13 +92,14 @@ class AutonomousEmailAgent:
             return self.generate_email()
 
         else:
-            # If the LLM returns an unrecognized instruction, fall back to using the current available data
             print("Error: Unrecognized instruction from LLM. Proceeding with available data.")
             return self.generate_email()
 
     # 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
         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)
         
@@ -120,11 +112,12 @@ 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}")
-            self.company_url = None
+            print(f"Error fetching company URL: {response.status_code}. Retrying with fallback or alternative...")
+            # Additional logic to retry with alternative API or handle error
 
-    # Action: Fetch LinkedIn data via Proxycurl
+    # Fetch LinkedIn data via Proxycurl
     def fetch_linkedin_data(self):
+        proxycurl_api_key = os.getenv("PROXYCURL_API_KEY")  # Fetch API key from environment
         if not self.linkedin_url:
             print("Action: No LinkedIn URL provided, using default bio.")
             self.bio = "A professional with diverse experience."
@@ -146,9 +139,11 @@ class AutonomousEmailAgent:
                 self.skills = ["Adaptable", "Hardworking"]
                 self.experiences = ["Worked across various industries"]
 
-    # Action: Fetch company information via Firecrawl API using company URL
+    # 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
         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 = {
@@ -162,16 +157,13 @@ 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. Using default info.")
+            print(f"Error: Unable to fetch company info via Firecrawl. Retrying or using fallback...")
             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 NVIDIA LLM with "Start with Why" framework
     def generate_email(self):
-        print("Action: Generating the email with the gathered information.")
+        print("Action: Generating the email using NVIDIA LLM with the gathered information.")
 
-        linkedin_text = f"Please find my LinkedIn profile at {self.linkedin}" if self.linkedin else ""
-
-        # Updated prompt to reflect Simon Sinek's "Start with Why" approach
         prompt = f"""
         Write a professional job application email applying for the {self.role} position at {self.company_name}.
 
@@ -194,33 +186,31 @@ class AutonomousEmailAgent:
         Email: {self.email}
         Phone: {self.phone}
         LinkedIn: {self.linkedin}
-        
+
         The email should not exceed {self.word_limit} words.
         """
 
-        url = "https://api.groq.com/openai/v1/chat/completions"
-        headers = {
-            "Authorization": f"Bearer {groq_api_key}",
-            "Content-Type": "application/json",
-        }
+        completion = client.chat.completions.create(
+            model="nvidia/llama-3.1-nemotron-70b-instruct",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.5,
+            top_p=1,
+            max_tokens=1024,
+            stream=True
+        )
 
-        data = {
-            "messages": [{"role": "user", "content": prompt}],
-            "model": "llama3-8b-8192"
-        }
+        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
 
-        response = requests.post(url, headers=headers, json=data)
-        if response.status_code == 200:
-            return response.json()["choices"][0]["message"]["content"].strip()
-        else:
-            print(f"Error: {response.status_code}, {response.text}")
-            return "Error generating email. Please check your API key or try again later."
+        return generated_email
 
     # Main loop following ReAct pattern
     def run(self):
         self.fetch_linkedin_data()  # Fetch LinkedIn data
-        # Let LLM autonomously decide and act
-        return self.autonomous_reasoning()  
+        return self.autonomous_reasoning()  # Let the LLM autonomously decide and act
 
 # Define the Gradio interface and the main app logic
 def gradio_ui():