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,7 +92,6 @@ 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()
 
@@ -123,7 +113,7 @@ class AutonomousEmailAgent:
             print(f"Error fetching company URL: {response.status_code}")
             self.company_url = None
 
-    # Action: Fetch LinkedIn data via Proxycurl
+    # Fetch LinkedIn data via Proxycurl
     def fetch_linkedin_data(self):
         if not self.linkedin_url:
             print("Action: No LinkedIn URL provided, using default bio.")
@@ -146,7 +136,7 @@ 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):
         print(f"Fetching company info for {company_url} using Firecrawl.")
         headers = {"Authorization": f"Bearer {firecrawl_api_key}"}
@@ -165,13 +155,12 @@ class AutonomousEmailAgent:
             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 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 +183,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():