Update app.py

app.py

@@ -1,150 +1,144 @@
 import streamlit as st
 import requests
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.metrics.pairwise import cosine_similarity
-from transformers import MarianMTModel, MarianTokenizer
-import sentencepiece
 
 # Set up the Streamlit page
 st.title("AI Opportunity Finder for Youth")
 st.write("Find Scholarships, Internships, Online Courses, and more!")
 
-# Function to get scholarships data from a mock API
+# Groq API URL and Authentication
+GROQ_API_URL = "https://api.groq.ai"
+API_KEY = "YOUR_GROQ_API_KEY"  # Replace with your actual Groq API Key
+
+# Function to fetch data from Groq API for scholarships
 def get_scholarships(location, interests):
-    url = "https://jsonplaceholder.typicode.com/posts"  # Mock API for testing
-    response = requests.get(url)
+    url = f"{GROQ_API_URL}/scholarships"
+    headers = {
+        'Authorization': f'Bearer {API_KEY}',
+        'Content-Type': 'application/json'
+    }
+    params = {"location": location, "interests": interests}
+    
+    response = requests.get(url, headers=headers, params=params)
     
     if response.status_code == 200:
-        # Return a list of mock scholarships
-        return [{"title": f"Scholarship {i+1}", "description": post['body'], "eligibility": "Any student from any background."} for i, post in enumerate(response.json())[:5]]
+        scholarships = response.json()
+        return [{"title": scholarship['title'], "description": scholarship['description'], "eligibility": scholarship['eligibility']} for scholarship in scholarships]
     else:
         return []
 
-# Function to get internships data from a mock API
+# Function to fetch data from Groq API for internships
 def get_internships():
-    url = "https://jsonplaceholder.typicode.com/posts"  # Mock API for testing
-    response = requests.get(url)
+    url = f"{GROQ_API_URL}/internships"
+    headers = {
+        'Authorization': f'Bearer {API_KEY}',
+        'Content-Type': 'application/json'
+    }
+    
+    response = requests.get(url, headers=headers)
     
     if response.status_code == 200:
-        # Return a list of mock internships
-        return [{"jobtitle": f"Internship {i+1}", "company": "Sample Company", "location": "Remote", "snippet": "Description of the internship."} for i in range(5)]
+        internships = response.json()
+        return [{"jobtitle": internship['jobtitle'], "company": internship['company'], "location": internship['location'], "snippet": internship['description']} for internship in internships]
     else:
         return []
 
-# Function to recommend opportunities based on user input
-def recommend_opportunities(user_interests, user_skills, opportunities):
-    # Combine user profile into a single string
-    user_profile = [f"{user_interests} {user_skills}"]
+# Function to recommend opportunities using Groq's recommendation system
+def recommend_opportunities(user_interests, user_skills, scholarships, internships):
+    # Combine user interests and skills into a profile for recommendation
+    user_profile = f"{user_interests} {user_skills}"
     
-    # Create text data for opportunities based on description & eligibility
-    opportunities_text = [f"{opportunity['description']} {opportunity['eligibility']}" for opportunity in opportunities]
+    # API request to get recommendations (assumed Groq API endpoint)
+    url = f"{GROQ_API_URL}/recommendations"
+    headers = {
+        'Authorization': f'Bearer {API_KEY}',
+        'Content-Type': 'application/json'
+    }
     
-    # Vectorize the text using TF-IDF
-    vectorizer = TfidfVectorizer(stop_words='english')
-    tfidf_matrix = vectorizer.fit_transform(opportunities_text + user_profile)
+    data = {
+        "profile": user_profile,
+        "opportunities": scholarships + internships
+    }
     
-    # Compute cosine similarity
-    cosine_sim = cosine_similarity(tfidf_matrix[-1], tfidf_matrix[:-1])
+    response = requests.post(url, json=data, headers=headers)
     
-    # Get the indices of the top 5 recommended opportunities
-    recommendations = cosine_sim[0].argsort()[-5:][::-1]
-    
-    # Return recommended opportunities
-    return [opportunities[i] for i in recommendations]
-
-# Function to load MarianMT translation model
-def load_translation_model(target_language):
-    model_name = f'Helsinki-NLP/opus-mt-en-{target_language}'
-    tokenizer = MarianTokenizer.from_pretrained(model_name)
-    model = MarianMTModel.from_pretrained(model_name)
-    return model, tokenizer
-
-# Function to translate text using MarianMT
-def translate_text(text, target_language):
-    try:
-        model, tokenizer = load_translation_model(target_language)
-        
-        # Tokenize and translate text
-        tokens = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
-        translated = model.generate(**tokens)
-        translated_text = tokenizer.decode(translated[0], skip_special_tokens=True)
-        
-        return translated_text
-    except Exception as e:
-        return f"Error during translation: {str(e)}"
+    if response.status_code == 200:
+        recommended_opportunities = response.json()
+        return recommended_opportunities
+    else:
+        return []
 
-# User input for profile
+# Streamlit Sidebar: User Profile Input
 st.sidebar.header("User Profile")
 location = st.sidebar.text_input("Location", "Pakistan")  # Default to 'Pakistan'
 skills = st.sidebar.text_input("Skills (e.g., Python, Marketing)")
 interests = st.sidebar.text_input("Interests (e.g., Technology, Science)")
 
-# Fetch scholarships based on user input
+# Fetch Scholarships and Internships
 scholarships = get_scholarships(location, interests)
+internships = get_internships()
 
-# Display scholarships if available
+# Display Scholarships if available
 if scholarships:
     st.write("Scholarships found:")
     for scholarship in scholarships:
-        st.write(f"Title: {scholarship['title']}")
-        st.write(f"Description: {scholarship['description']}")
-        st.write(f"Eligibility: {scholarship['eligibility']}")
+        st.write(f"**Title:** {scholarship['title']}")
+        st.write(f"**Description:** {scholarship['description']}")
+        st.write(f"**Eligibility:** {scholarship['eligibility']}")
         st.write("---")
 else:
     st.write("No scholarships found based on your criteria.")
 
-# Fetch internships based on user input
-internships = get_internships()
-
-# Display internships if available
+# Display Internships if available
 if internships:
     st.write("Internships found:")
     for internship in internships:
-        st.write(f"Title: {internship['jobtitle']}")
-        st.write(f"Company: {internship['company']}")
-        st.write(f"Location: {internship['location']}")
-        st.write(f"Snippet: {internship['snippet']}")
+        st.write(f"**Title:** {internship['jobtitle']}")
+        st.write(f"**Company:** {internship['company']}")
+        st.write(f"**Location:** {internship['location']}")
+        st.write(f"**Snippet:** {internship['snippet']}")
         st.write("---")
 else:
-    st.write("No internships found.")
+    st.write("No internships found based on your criteria.")
 
-# AI-based recommendations for opportunities
+# AI-based Recommendations for Opportunities
 if st.sidebar.button("Get AI Recommendations"):
-    # Combine scholarships and internships for recommendations
-    all_opportunities = scholarships + internships
-    
-    # Get AI recommendations based on user input
-    recommended_opportunities = recommend_opportunities(interests, skills, all_opportunities)
+    recommended_opportunities = recommend_opportunities(interests, skills, scholarships, internships)
     
-    # Display recommended opportunities
-    st.write("Recommended Opportunities based on your profile:")
-    for opportunity in recommended_opportunities:
-        st.write(f"Title: {opportunity['title']}")
-        st.write(f"Description: {opportunity['description']}")
-        st.write(f"Eligibility: {opportunity.get('eligibility', 'Not available')}")
-        st.write("---")
+    if recommended_opportunities:
+        st.write("Recommended Opportunities based on your profile:")
+        for opportunity in recommended_opportunities:
+            st.write(f"**Title:** {opportunity['title']}")
+            st.write(f"**Description:** {opportunity['description']}")
+            st.write(f"**Eligibility:** {opportunity.get('eligibility', 'Not available')}")
+            st.write("---")
+    else:
+        st.write("No AI recommendations found.")
 
-# Language selection
+# Language selection for translation (optional)
 languages = {
-    'English': 'english',
-    'German': 'deutch',
-    'French': 'french',
-    'Spanish': 'spanish',
-    'Italian': 'italian',
-    'Portuguese': 'portugese',
-    'Chinese': 'chinese',
-    'Arabic': 'arabic',
-    'Russian': 'russian',
-    'Japanese': 'japanese',
-    'Korean': 'korean',
-    'Urdu': 'urdu'
+    'English': 'English',
+    'German': 'German',
+    'French': 'French',
+    'Spanish': 'Spanish',
+    'Italian': 'Italian',
+    'Portuguese': 'Portuguese',
+    'Chinese': 'Chinese',
+    'Arabic': 'Arabic',
+    'Russian': 'Russian',
+    'Japanese': 'Japanese',
+    'Korean': 'Korean',
+    'Urdu': 'Urdu'
 }
 
 # Dropdown for language selection
 selected_language = st.selectbox("Select Language", list(languages.keys()))
 
-# Translate the opportunity description based on the selected language
+# Translate text (Optional)
+def translate_text(text, target_language):
+    # Example translation logic (replace with actual API call if necessary)
+    return f"Translated {text} to {target_language}"
+
+# Display the translated text (if selected language is not English)
 if selected_language != 'English':
-    # Translate the title of the app or a sample text
     translated_text = translate_text("Hello, welcome to AI Opportunity Finder!", languages[selected_language])
     st.write(f"Translated Text ({selected_language}): {translated_text}")