Update app.py

app.py

@@ -1,106 +1,111 @@
 import os
 import streamlit as st
 import pandas as pd
-import requests
+import google.generativeai as genai
 
-# Load the scholarships data
+# Configuration
+os.environ['GOOGLE_API_KEY'] = os.getenv('GOOGLE_API_KEY', 'your_key_here')
+
+# Load scholarships data
 @st.cache_data
-def load_scholarships_data():
+def load_scholarships():
     return pd.read_csv("scholarships_data.csv")
 
-# Function to filter scholarships based on user input
-def recommend_scholarships(data, user_details):
-    filtered_scholarships = []
-    for _, row in data.iterrows():
-        eligibility = row["Eligibility"].lower()
+# Initialize Generative AI
+def get_genai_client():
+    try:
+        genai.configure(api_key=os.environ['GOOGLE_API_KEY'])
+        return genai.GenerativeModel('gemini-pro')
+    except Exception as e:
+        st.error(f"AI Initialization Error: {str(e)}")
+        return None
+
+# Recommendation engine
+def recommend_scholarships(user_data, scholarships):
+    matches = []
+    for _, row in scholarships.iterrows():
+        eligibility = row['Eligibility'].lower()
         if (
-            (user_details["citizenship"] == "india" and "indian" in eligibility) or
-            (user_details["age"] <= 35 and "below 35" in eligibility) or
-            (user_details["income"] <= 250000 and "₹2,50,000" in eligibility) or
-            (user_details["education_level"] in eligibility) or
-            (user_details["category"] in eligibility)
+            (user_data['citizenship'] in eligibility) and
+            (user_data['age'] <= parse_age(eligibility)) and
+            (user_data['income'] <= parse_income(eligibility)) and
+            (user_data['education'] in eligibility) and
+            (user_data['category'] in eligibility)
         ):
-            filtered_scholarships.append(row)
-    return pd.DataFrame(filtered_scholarships)
+            matches.append(row)
+    return pd.DataFrame(matches)
 
-# Function to call Gemini API
-def query_gemini(prompt):
-    gemini_api_key = os.getenv("GEMINI_API_KEY")
-    if not gemini_api_key:
-        st.error("Gemini API Key not found in environment variables.")
-        return None
+# Helper functions for eligibility parsing
+def parse_age(eligibility):
+    if 'below 35' in eligibility:
+        return 35
+    return 100  # Default if no age restriction
 
-    url = "https://api.gemini.com/v1/query"
-    headers = {
-        "Authorization": f"Bearer {gemini_api_key}",
-        "Content-Type": "application/json",
-    }
-    payload = {"prompt": prompt}
-    response = requests.post(url, headers=headers, json=payload)
-    if response.status_code == 200:
-        return response.json().get("response", "")
-    else:
-        return "Error: Unable to fetch response from Gemini API."
+def parse_income(eligibility):
+    if '₹2,50,000' in eligibility:
+        return 250000
+    return float('inf')  # Default if no income restriction
 
-# Streamlit App
+# Streamlit app
 def main():
-    st.title("Scholarship Recommendation System")
+    st.title("AI-Powered Scholarship Advisor")
+    
+    # User input form
+    with st.form("scholarship_form"):
+        st.header("Student Profile")
+        citizenship = st.selectbox("Citizenship", ["India", "Other"]).lower()
+        age = st.number_input("Age", 1, 100, 25)
+        income = st.number_input("Annual Family Income (₹)", 0, 10000000, 500000)
+        education = st.selectbox("Education Level", 
+                                ["Class 10", "Class 12", "Undergraduate", 
+                                 "Postgraduate", "PhD"]).lower()
+        category = st.selectbox("Category", 
+                               ["General", "OBC", "SC", "ST", "EWS", "Minority"]).lower()
+        
+        submitted = st.form_submit_button("Find Scholarships")
 
-    # User Input Form
-    st.header("Student Scholarship Application Form")
-    with st.form("student_form"):
-        st.subheader("Personal Details")
-        citizenship = st.selectbox("Citizenship", ["India", "Other"])
-        age = st.number_input("Age", min_value=1, max_value=100)
-        income = st.number_input("Annual Family Income (in ₹)", min_value=0, max_value=10000000)
-        education_level = st.selectbox(
-            "Education Level",
-            ["Class 10", "Class 12", "Undergraduate", "Postgraduate", "PhD"]
-        )
-        category = st.selectbox(
-            "Category",
-            ["General", "OBC", "SC", "ST", "EWS", "Minority"]
-        )
+    if submitted:
+        # Validate inputs
+        if not os.environ.get('GOOGLE_API_KEY'):
+            st.warning("Please set GOOGLE_API_KEY environment variable")
+            return
 
-        submit_button = st.form_submit_button("Find Scholarships")
-
-    # Process form submission
-    if submit_button:
-        # Load scholarships data
-        scholarships_data = load_scholarships_data()
-
-        # Prepare user details
-        user_details = {
-            "citizenship": citizenship.lower(),
-            "age": age,
-            "income": income,
-            "education_level": education_level.lower(),
-            "category": category.lower(),
+        # Load data and generate recommendations
+        scholarships = load_scholarships()
+        user_data = {
+            'citizenship': citizenship,
+            'age': age,
+            'income': income,
+            'education': education,
+            'category': category
         }
-
-        # Filter scholarships
-        recommended_scholarships = recommend_scholarships(scholarships_data, user_details)
+        results = recommend_scholarships(user_data, scholarships)
 
         # Display results
-        st.subheader("Recommended Scholarships")
-        if not recommended_scholarships.empty:
-            for _, scholarship in recommended_scholarships.iterrows():
-                st.markdown(f"**{scholarship['Scholarship Name']}**")
-                st.write(f"**Eligibility:** {scholarship['Eligibility']}")
-                st.write(f"**Link:** {scholarship['Link']}")
-                st.write("---")
-        else:
-            st.warning("No scholarships found matching your criteria.")
+        st.subheader(f"Found {len(results)} Matching Scholarships")
+        for _, row in results.iterrows():
+            st.markdown(f"""
+                **{row['Scholarship Name']}**  
+                **Eligibility:** {row['Eligibility']}  
+                [Apply Here]({row['Link']})
+                """)
+            st.divider()
 
-        # Ask Gemini for additional advice
-        prompt = (
-            f"Provide advice for a {age}-year-old {citizenship} citizen with an annual family income of ₹{income}, "
-            f"pursuing {education_level}, belonging to the {category} category, to find suitable scholarships."
-        )
-        gemini_response = query_gemini(prompt)
-        if gemini_response:
-            st.subheader("Additional Advice from Gemini")
-            st.write(gemini_response)
+        # Generate AI-powered advice
+        model = get_genai_client()
+        if model:
+            prompt = f"""
+                Act as an experienced education counselor. 
+                For a {age}-year-old {citizenship} citizen with:
+                - Annual income: ₹{income}
+                - Education level: {education}
+                - Category: {category}
+                Provide personalized advice about these scholarships:
+                {results['Scholarship Name'].tolist()}
+                """
+            response = model.generate_content(prompt)
+            st.subheader("AI Advisor Recommendations")
+            st.write(response.text)
 
 if __name__ == "__main__":
     main()