File Uploading

README.md

@@ -1,10 +1 @@
----
-title: Saral Ai
-emoji: 📚
-colorFrom: green
-colorTo: green
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# SARAL-AI

SERP.py

@@ -0,0 +1,88 @@
+import requests
+import os 
+from dotenv import load_dotenv
+from postgres_db import fetch_from_saral_data , data_input , check_completeness, cur, get_connection
+
+
+load_dotenv()
+
+SERP_API_KEY = os.getenv("SERP_API_KEY")
+
+
+
+
+
+def query_making(data):
+      query = "site:linkedin.com/in"
+
+      if data['job_title']:
+            query += f' "{data["job_title"]}"'
+            
+      if data['skills']:
+            for i in data['skills']:
+                  query += f' "{i}"'
+            
+      if data['experience']:
+            exp = data["experience"]
+            query += f' "{exp} years" OR "{exp}+ years"'
+            
+      if data['location']:
+            if type(data['location']) == list:
+                  for i in data['location']:
+                        query += f' "{i}"'
+            else:
+                  query += f' "{data["location"]}"'
+            
+            
+      if data['work_preference']:
+            query += f' "{data["work_preference"]}"'
+            
+      if data['job_type']:
+            query += f' "{data["job_type"]}"'
+            
+      
+      add_keywords = ' -"job" -"jobs" -"hiring" -"vacancy" -"openings" -"career" -"apply"'
+      query += add_keywords
+      # print(query)
+
+      return query, data['location']
+
+
+def serp_api_call(query,start = 0, results_per_page = 10):
+      data = None
+
+      # SERP API CALL
+
+      params = {
+            "engine": "google",
+            "q": query.strip(),
+            "api_key": SERP_API_KEY,
+            "hl": "en",
+            "gl": "in",
+            "google_domain": "google.co.in",
+            "location": "India",
+            "num": results_per_page,
+            "start": start,
+            "safe": "active"
+            
+      }
+
+      try:
+            response = requests.get("https://serpapi.com/search", params=params)
+            if response.status_code == 200:
+                  data = response.json()
+                  
+            else:
+                  print(f"Request failed with status code: {response.status_code}")
+      except:
+            pass
+
+      return data
+
+
+
+
+
+
+
+

apify.py

@@ -0,0 +1,65 @@
+from apify_client import ApifyClient
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+APIFY_API_KEY = os.getenv("APIFY_API_TOKEN")
+
+
+linkedin_profiles = {
+    "1": "https://linkedin.com/in/ramya-rajendran-730b46a9",
+    "2": "https://linkedin.com/in/dhruv-patel-39a333263",
+    "3": "https://linkedin.com/in/harsh-patel9797",
+    "4": "https://linkedin.com/in/denish-patel-64a8bb183",
+    "5": "https://linkedin.com/in/swapnildjoshi",
+    "6": "https://linkedin.com/in/bhavin-vaghasiya-82839522a",
+    "7": "https://linkedin.com/in/dharmesh-sharma-6a09a0192",
+    "8": "https://linkedin.com/in/bhawanii-raajpurohit-72991b1b5",
+    "9": "https://linkedin.com/in/trushali-miyani-69aa26276",
+    "10": "https://linkedin.com/in/isha-bhanderi-244638246",
+}
+
+client = ApifyClient(APIFY_API_KEY)
+
+def apify_call(linkedin_profiles):
+      list_links = list(linkedin_profiles.values())
+      
+      print(list_links)
+
+      run_input = {
+            "profileUrls": list_links
+      }
+
+      run = client.actor("2SyF0bVxmgGr8IVCZ").call(run_input=run_input)
+
+      cleaned_profiles = []
+
+
+      for idx, item in enumerate(client.dataset(run["defaultDatasetId"]).iterate_items(),start=1):
+            # apify_json[idx] = item
+
+            # raw_skills = item.get("skills", [])
+            # skill_titles = [s.get("title") for s in raw_skills if "title" in s]
+
+            # profile_data = {
+            #       "fullName":item.get("fullName"),
+            #       "profilePic": item.get("profilePic"),
+            #       "linkedinUrl":item.get("linkedinUrl"),
+            #       "headline":item.get("headline"),
+            #       "about":item.get("about"),
+            #       "skills":skill_titles,
+            #       "email": item.get("email"),
+            #       "addressWithCountry": item.get("addressWithCountry"),
+            #       "experience": item.get("experience")
+            # }
+
+            # profile_data = {k: v for k, v in profile_data.items() if v}
+            cleaned_profiles.append(item)
+
+
+
+      
+      return cleaned_profiles
+            
+

nlp_parsed.py

@@ -0,0 +1,142 @@
+import re 
+import os
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+import json
+from postgres_db import store_prompt, conn
+
+load_dotenv()
+
+SERP_API_KEY = os.getenv("SERP_API_KEY")
+endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+api_key = os.getenv("AZURE_OPENAI_API_KEY")
+api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+deployment = os.getenv("AZURE_OPENAI_DEPLOYMENT")
+
+
+try:
+    client = AzureOpenAI(api_key=api_key, api_version=api_version, azure_endpoint=endpoint)
+except Exception as e:
+   print(f"Failed to initialize Azure OpenAI client: {e}")
+    
+
+def parse_recruiter_query(query):
+    """Parse recruiter query using AI to extract structured data"""
+    if not client:
+        return {"error": "Azure OpenAI client not available"}
+
+    try:
+        system_prompt = """You are an AI assistant that extracts structured recruitment information from natural language queries.
+
+        Fields to extract:
+        - job_title: ONLY the exact position title they're hiring for (e.g., "Python Developer", "Data Scientist"). 
+          DO NOT include phrases like "looking for", "need a", "hiring", etc.
+        - skills: Array of required technical skills mentioned (e.g., ["Python", "Django", "SQL"])
+        - experience: Required experience in years (numeric value or range). For fresher candidates, use "fresher" exactly.
+        - location: Array of city names if multiple cities are mentioned, or single city name as Array if only one city is mentioned.
+        - work_preference: Work mode preference - one of: "remote", "onsite", "hybrid", null
+        - job_type: Employment type - one of: "full-time", "part-time", "contract", "internship", null
+        - is_indian: true if the job location(s) are in India, false otherwise. 
+                     IMPORTANT: If no location is mentioned, always set is_indian = true.
+
+        CRITICAL INSTRUCTIONS:
+        1. For job_title, NEVER include phrases like "looking for", "need", "hiring", etc.
+        2. For experience, if the query mentions "fresher", "fresh graduate", "entry level", use exactly "fresher"
+        3. For is_indian, check the location(s). If the location(s) are Indian cities or the query context is India-based, return true. 
+           If no location is mentioned at all, default to true.
+        4. Return ONLY valid JSON without any explanation or additional text.
+        5. Use your knowledge to recognize job titles across all industries and domains."""
+
+        user_prompt = f"""Extract recruitment information from this query: "{query}"
+
+        Examples of correct extraction:
+
+        Input: "We are looking for a Python developer with 3 years experience from Mumbai"
+        Output: {{"job_title": "Python Developer", "skills": ["Python"], "experience": "3", "location": ["Mumbai"], "work_preference": null, "job_type": null, "is_indian": true}}
+
+        Input: "Need a senior React frontend developer with Redux, TypeScript, 5+ years"
+        Output: {{"job_title": "React Frontend Developer", "skills": ["React", "Redux", "TypeScript"], "experience": "5+", "location": null, "work_preference": null, "job_type": null, "is_indian": true}}
+
+        Input: "python developer with 2 year of experience from surat, ahmedabad and mumbai"
+        Output: {{"job_title": "Python Developer", "skills": ["Python"], "experience": "2", "location": ["Surat", "Ahmedabad", "Mumbai"], "work_preference": null, "job_type": null, "is_indian": true}}
+
+        Input: "Remote React developer needed, 5 years experience, Redux, TypeScript"
+        Output: {{"job_title": "React Developer", "skills": ["React", "Redux", "TypeScript"], "experience": "5", "location": null, "work_preference": "remote", "job_type": null, "is_indian": true}}
+
+        Input: "Looking for fresher Java developer from Delhi"
+        Output: {{"job_title": "Java Developer", "skills": ["Java"], "experience": "fresher", "location": ["Delhi"], "work_preference": null, "job_type": null, "is_indian": true}}
+
+        Now extract from the query: "{query}"
+
+        Remember: 
+        1. Extract ONLY the job title without any prefixes like "looking for", "need", etc.
+        2. Extract ONLY the city/location name without additional text.
+        3. For fresher candidates, use exactly "fresher" as experience value.
+        4. For is_indian: true if job location(s) are Indian, false otherwise. If no location is provided, always return true.
+        5. Return ONLY valid JSON."""
+
+        response = client.chat.completions.create(
+            model=deployment,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.0,
+            max_tokens=500
+        )
+
+        return json.loads(response.choices[0].message.content)
+
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON returned from AI"}
+    except Exception as e:
+        return {"error": f"Unexpected error: {str(e)}"}
+
+
+
+def prompt_enhancer(prompt: str) -> str:
+    """Enhance recruiter prompt to be clearer and more structured"""
+    if not client:
+        return prompt  # fallback: return original if Azure client not available
+
+    try:
+        system_prompt = """You are an AI assistant that enhances recruiter job search prompts.
+        Your goal is to:
+        1. Clean up grammar and spelling mistakes.
+        2. Expand shorthand into full professional wording.
+        3. Preserve all important details: job title, skills, experience, location, work mode, job type.
+        4. Do NOT invent new requirements — only clarify what’s already in the query.
+        5. Do not copy examples literally — adapt based on the actual input.
+        6. Return ONLY the enhanced recruiter prompt as plain text (no JSON)."""
+
+        user_prompt = f"""Rewrite and enhance this recruiter query for clarity:
+
+        Input: "{prompt}"
+
+        Example Enhancements:
+        - "python dev 2yr exp surat" → "Looking for a Python Developer with 2 years of experience in Surat."
+        - "need react js fresher remote" → "Hiring a React.js Developer at fresher level for a remote role."
+        - "java 5+ exp ahmedabad onsite" → "Looking for a Java Developer with over 5 years of experience for an onsite role in Ahmedabad."
+        - "data analyst 3 years bangalore hybrid" → "Seeking a Data Analyst with 3 years of experience for a hybrid position in Bangalore."
+        - "ui ux designer fresher mumbai internship" → "Hiring a UI/UX Designer, fresher level, for an internship role in Mumbai."
+
+        Now enhance this query: "{prompt}"
+        """
+
+        response = client.chat.completions.create(
+            model=deployment,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.5,   # slightly more creative
+            max_tokens=200
+        )
+
+        enhanced_prompt = response.choices[0].message.content.strip()
+        return enhanced_prompt
+
+    except Exception as e:
+        print(f"Error in prompt_enhancer: {e}")
+        return prompt  # fallback to original
+

postgres_db.py

@@ -0,0 +1,247 @@
+import psycopg2
+import json
+from datetime import datetime, timedelta
+
+
+
+hostname = "13.201.135.196"
+database = "saral_ai"
+username = "saral_user"
+pwd = "8k$ScgT97y9£>D"
+port_id = 5432
+
+
+
+conn = None
+cur = None
+
+
+def get_connection():
+    return psycopg2.connect(
+        host=hostname,
+        dbname=database,
+        user=username,
+        password=pwd,
+        port=port_id
+    )
+
+def check_completeness(cur, name, location, linkedin_url, headline, skills, experience):
+    is_complete = True
+    message = "this data is complete"
+
+    required_fields = [name, location, linkedin_url]
+    for field in required_fields:
+        if field in [None, "", []]:
+            is_complete = False
+            message = "missing required fields"
+            break
+
+    cur.execute("SELECT id FROM saral_data WHERE linkedin_url = %s", (linkedin_url,))
+    existing = cur.fetchone()
+    if existing:
+        return False, "this data is duplicate", False
+
+    optional_fields = [headline, skills, experience]
+    for field in optional_fields:
+        if field in [None, "", []]:
+            is_complete = False
+            message = "some optional fields missing"
+            break
+
+    return True, message, is_complete
+
+
+
+
+
+
+
+def data_input(json_data):
+      insert_script = '''
+            INSERT INTO saral_data
+            (name, location, email, linkedin_url, headline, skills, about, experience, profile_pic, is_complete, created_at)
+            VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
+      '''    
+      with conn.cursor() as cur:
+            for d in json_data:
+                  name = d.get("fullName")
+                  location = d.get("addressWithCountry")
+                  email = d.get("email")
+                  linkedin_url = d.get("linkedinUrl")
+                  headline = d.get("headline")
+                  profile_pic = d.get("profilePic")
+
+                  # Safe parsing of skills
+                  skills_raw = d.get("skills", [])
+                  if isinstance(skills_raw, str):
+                        try:
+                              skills_raw = json.loads(skills_raw)
+                        except:
+                              skills_raw = []
+                  skills_list = [s.get("title") for s in skills_raw if isinstance(s, dict)]
+                  skills = json.dumps(skills_list)
+
+                  # Safe parsing of experiences
+                  experience_raw = d.get("experiences", [])
+                  if isinstance(experience_raw, str):
+                        try:
+                              experience_raw = json.loads(experience_raw)
+                        except:
+                              experience_raw = []
+                  experience = json.dumps(experience_raw)
+
+                  about = d.get("about")
+
+                  success, message, is_complete = check_completeness(
+                        cur, name, location, linkedin_url, headline, skills_list, experience_raw
+                  )
+                  print(message)
+                  
+                  if not is_complete:  
+                        continue 
+
+                  created_at = datetime.now()
+                  cur.execute(
+                        insert_script,
+                        (
+                              name, location, email, linkedin_url, headline,
+                              skills, about, experience, profile_pic, is_complete, created_at
+                        )
+                  )
+                  
+                  conn.commit()
+
+            
+
+def fetch_from_saral_data(serp_data, conn):
+      if not serp_data or not isinstance(serp_data, dict):
+        print("⚠️ fetch_from_saral_data: serp_data is None or not a dict")
+        return [], []   # return empty lists safely
+  
+      results = []
+      remaining = []
+      one_month_ago = datetime.now() - timedelta(days=30)
+
+      serp_json = {}
+      for idx, result in enumerate(serp_data.get("organic_results", []), start=1):
+            link = result.get("link")
+            if link and ("linkedin.com/in/" in link or "in.linkedin.com/in/" in link):
+                  clean_link = link.replace("in.linkedin.com", "linkedin.com")
+                  serp_json[idx] = clean_link
+
+      # create a fresh cursor
+      with conn.cursor() as cur:
+            for link in serp_json.values():
+                  cur.execute("""
+                        SELECT name, location, email, linkedin_url, headline, skills, about, experience, profile_pic, is_complete, created_at
+                        FROM saral_data
+                        WHERE linkedin_url = %s AND created_at >= %s
+
+                  """, (link, one_month_ago))
+
+                  row = cur.fetchone()
+                  if row:
+                        results.append({
+                        "fullName": row[0] if row[0] else "Unknown",
+                        "addressWithCountry": row[1] if row[1] else "Unknown",
+                        "email": row[2] if row[2] else "-",
+                        "linkedinUrl": row[3] if row[3] else "-",
+                        "headline": row[4] if row[4] else "-",
+                        "skills": row[5] if row[5] else [],
+                        "about": row[6] if row[6] else "",
+                        "experiences": row[7] if row[7] else [],
+                        "profilePic": row[8] if row[8] else None,   
+                        "is_complete": row[9],
+                        "created_at": row[10]
+                        })
+
+
+                  else:
+                        remaining.append(link)
+
+      return results, remaining
+
+
+def store_prompt(conn, prompt: str, parsed_json: dict):
+    job_title = parsed_json.get("job_title")
+    skills = parsed_json.get("skills", [])
+    experience = parsed_json.get("experience")
+    location = parsed_json.get("location", [])
+    work_preference = parsed_json.get("work_preference")
+    job_type = parsed_json.get("job_type")
+    is_indian = parsed_json.get("is_indian")
+
+    try:
+        with conn.cursor() as cur:
+            cur.execute("""
+                INSERT INTO saral_prompts
+                (prompt, job_title, skills, experience, location, work_preference, job_type, created_at,is_indian)
+                VALUES (%s, %s, %s, %s, %s, %s, %s, %s,%s)
+            """, (
+                prompt,
+                job_title,
+                json.dumps(skills) if skills else None,   # ensure proper type
+                experience,
+                location if location else None,
+                work_preference,
+                job_type,
+                datetime.now(),
+                is_indian
+            ))
+        conn.commit()
+    except Exception as e:
+        print("Error inserting prompt:", e)
+        conn.rollback()   
+
+
+
+
+try:
+      conn = psycopg2.connect(
+            host=hostname, dbname=database, user=username, password=pwd, port=port_id
+      )
+
+      cur = conn.cursor()
+
+      create_script = """
+                  CREATE TABLE IF NOT EXISTS saral_data (
+                  id SERIAL PRIMARY KEY,
+                  name TEXT,
+                  location TEXT,
+                  email TEXT,
+                  linkedin_url TEXT,
+                  headline TEXT,
+                  skills JSONB,
+                  about TEXT,
+                  experience JSONB,
+                  profile_pic TEXT,          
+                  is_complete BOOLEAN,
+                  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                  );
+            """
+      
+      # cur.execute(create_script)
+            
+      
+      
+
+      conn.commit()
+      
+      
+      
+      
+except Exception as error:
+    print(error)
+
+
+finally:
+#     if cur is not None:
+#         cur.close()
+#     if conn is not None:
+#         conn.close()
+      pass
+
+
+
+
+

requirements.txt

@@ -0,0 +1,8 @@
+flask
+streamlit
+python-dotenv
+openai
+apify-client
+psycopg2-binary
+requests
+gunicorn

saral-ai.py

@@ -0,0 +1,301 @@
+import streamlit as st
+import re
+import os
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+import json
+from nlp_parsed import parse_recruiter_query,prompt_enhancer
+from SERP import query_making, serp_api_call
+from apify import apify_call
+from validate import validate_function, score_candidates
+from postgres_db import fetch_from_saral_data, check_completeness, data_input, cur, conn, store_prompt
+
+
+st.set_page_config(page_title="LinkedIn Recruiter Assistant", page_icon="🎯")
+
+
+if "parsed_data" not in st.session_state:
+    st.session_state.parsed_data = {}
+
+
+if "matched_results" not in st.session_state:
+    st.session_state.matched_results = []
+if "unmatched_results" not in st.session_state:
+    st.session_state.unmatched_results = []
+    
+    
+if "progress_placeholder" not in st.session_state:
+    st.session_state.progress_placeholder = None
+if "progress" not in st.session_state:
+    st.session_state.progress = None
+    
+
+if "current_page" not in st.session_state:
+    st.session_state.current_page = 0
+if "run_search" not in st.session_state:
+    st.session_state.run_search = False
+    
+    
+if "user_input" not in st.session_state:
+    st.session_state.user_input = ""
+    
+
+st.header("Saral AI")
+
+user_input = st.text_area(
+    "Enter your query here:",
+    placeholder="Enter your query here",
+    key="user_input_box",
+    value=st.session_state.user_input  # always pull from session_state
+)
+
+
+st.session_state.user_input = user_input
+
+
+# Show query parsing immediately (live preview)
+if user_input.strip():
+    parsed_data = parse_recruiter_query(user_input)   
+    
+    
+    st.session_state.parsed_data = parsed_data
+
+    if "error" in parsed_data:
+        st.error(parsed_data["error"])
+    elif parsed_data.get("is_indian") == False:
+        print("Our platform is not allowing search for out of india")
+    else:
+        with st.expander("Query", expanded=True):
+            col1, col2 = st.columns([1, 1])
+            with col1:
+                st.markdown(f'**Job Title:** {parsed_data.get("job_title", "None")}')
+                st.markdown(f'**Skills:** {parsed_data.get("skills", "None")}')
+                st.markdown(
+                    f'**Experience:** {parsed_data.get("experience","None")} years of Experience'
+                )
+                st.markdown(f'is_indian :{parsed_data.get("is_indian","None")}')
+            with col2:
+                st.markdown(f'**Location:** {parsed_data.get("location", "None")}')
+                st.markdown(
+                    f'**Work Preference:** {parsed_data.get("work_preference", "None")}'
+                )
+                st.markdown(f'**Job Type:** {parsed_data.get("job_type", "None")}')
+
+
+
+# Enhance prompt button
+if st.button("Enhance Prompt", use_container_width=True):
+    enhanced = prompt_enhancer(st.session_state.user_input)
+
+    # Store only in your own session_state variable
+    st.session_state.user_input = enhanced
+
+    # force rerun so text_area shows updated text
+    # st.experimental_rerun()
+    
+    
+
+# Only fetch SERP + Apify when button clicked
+if st.button(
+    "Enter",
+    use_container_width=True,
+    disabled=(parsed_data.get("is_indian") is False)  # disable only if explicitly False
+):
+    st.session_state.current_page = 0  # reset pagination
+    st.session_state.run_search = True
+
+
+if st.session_state.run_search:
+    if not user_input.strip():
+        st.warning("Please enter a valid query.")
+        st.stop()
+    
+    
+
+    store_prompt(conn,user_input,parsed_data)
+    
+    # Progress bar
+    st.session_state.progress_placeholder = st.empty()
+    st.session_state.progress = st.session_state.progress_placeholder.progress(0)
+    status = st.empty()
+
+    if user_input.strip() and "error" not in parsed_data:
+        query, location = query_making(parsed_data) # getting query like https:://linkedin.com --- AND location list 
+        
+        print(query)
+ 
+        
+        ### pagination concept 
+        
+        if st.session_state.current_page >= 0 :
+            results_per_page = 10
+            start = st.session_state.current_page * results_per_page
+            
+            serp_data = serp_api_call(
+                query,
+                start= start,
+                results_per_page=10
+            )
+            
+        
+            saral_data, remain_urls = fetch_from_saral_data(serp_data, conn)
+            
+            print(remain_urls)
+            
+            
+            st.session_state.progress.progress(30)
+            
+            serp_json = {}
+            
+            apify_json = {}
+            
+            if len(remain_urls) >= 1:
+                for idx, i in enumerate(remain_urls,start=1):
+                    serp_json[idx] = i
+                    
+                apify_json = apify_call(serp_json)
+                st.session_state.progress.progress(70)
+                
+
+            if apify_json:
+                total_candidates = saral_data + apify_json
+                
+            else:
+                total_candidates = saral_data
+             
+            data_input(total_candidates)
+
+            # Validate funciton (location)
+            matched, unmatched = validate_function(location, total_candidates)
+            st.session_state.progress.progress(70)
+            
+            
+            
+            matched = score_candidates(parsed_data , matched)
+            
+            st.session_state.matched_results = matched
+            st.session_state.unmatched_results = unmatched
+            
+            st.session_state.progress.progress(100)
+            st.session_state.progress_placeholder.empty()
+            st.session_state.progress = None
+            st.session_state.progress_placeholder = None
+
+    else:
+        st.warning("Please enter a valid query.")
+
+
+if st.session_state.matched_results:
+    
+    # length of Matched and unmatched profiles
+    col1, col2 = st.columns([1, 1])
+    with col1:
+        st.success(f"Matched Profiles: {len(st.session_state.matched_results)}")
+    with col2:
+        st.warning(f"Unmatched Profiles: {len(st.session_state.unmatched_results)}")
+    
+    
+    
+    
+    col1, col2, col3 = st.columns([1,2,1])
+    with col1:
+        if st.button("< Previous") and st.session_state.current_page > 0:
+            st.session_state.current_page -= 1
+            st.session_state.run_search = True 
+        
+    with col2:
+        st.write(f'Current Page {st.session_state.current_page + 1}')
+
+    with col3:
+        if st.button("Next >"):
+            st.session_state.current_page += 1
+            st.session_state.run_search = True 
+           
+
+    st.subheader("Candidates Profiles")
+    for idx, profiles in enumerate(st.session_state.matched_results, start=1):
+        with st.expander(f"{idx}. {profiles.get('fullName', 'Unknown')}"):
+            st.json(profiles)
+            
+        with st.expander(
+            f"{idx}. {profiles.get('fullName', 'Unknown')} • Score: {profiles.get('score','None')} ", expanded=True
+        ):
+            col1, col2 = st.columns([1, 2])
+            with col1:
+                image = profiles.get("profilePic")
+
+                temp_image = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRDVO09x_DXK3p4Mt1j08Ab0R875TdhsDcG2A&s"
+
+                if profiles.get("profilePic"):
+                    st.image(profiles.get("profilePic"), width=150)
+                else:
+                    st.image(temp_image, width=150)
+
+                st.markdown(f"**Location:** {profiles.get('addressWithCountry','-')}")
+                st.markdown(f"**Email:** {profiles.get('email','None')}")
+
+                
+                experiences = profiles.get("experiences", [])
+                open_to_work = True  # default
+
+                for exp in experiences:
+                    caption = exp.get("caption", "")
+                    if "Present" in caption:   # if still working
+                        open_to_work = False
+                        break
+
+                st.markdown(f"**Open to Work:** {'False' if not open_to_work else 'True'}")
+
+                st.markdown(
+                    f"**LinkedIn:** [LinkedIn]({profiles.get('linkedinUrl','')})"
+                )
+
+
+            with col2:
+                st.markdown(f"### {profiles.get('fullName')}")
+                if profiles.get("headline"):
+                    st.markdown(f"*{profiles.get('headline')}*")
+
+                skills_raw = profiles.get("skills", [])
+                skill_titles = [
+                    s.get("title")
+                    for s in skills_raw
+                    if isinstance(s, dict) and "title" in s
+                ]
+                if skill_titles:
+                    st.markdown("**Skills:** " + " • ".join(skill_titles[:10]))
+
+                if profiles.get("about"):
+                    about = profiles.get("about")
+                    st.markdown(
+                        "**About:** " + (about[:250] + "..." if len(about) > 250 else about)
+                    )
+
+                if profiles.get("experiences"):
+                    st.markdown("**Experience**")
+                    for exp in profiles["experiences"]:
+                        title = exp.get("title", "")
+                        subtitle = exp.get("subtitle") or exp.get("metadata", "")
+                        caption = exp.get("caption", "")
+
+                        # Print main line
+                        st.write(f"• {title} at {subtitle} — {caption}")
+
+                        # Print description if available
+                        if exp.get("description"):
+                            for desc in exp["description"]:
+                                if isinstance(desc, dict) and "text" in desc:
+                                    st.markdown(f"    - {desc['text']}")
+
+                if profiles.get("is_complete"):
+                    st.markdown(f'{profiles.get("is_complete")}')
+
+    if st.session_state.unmatched_results:
+        st.subheader("Unmatched Profiles")
+        for idx, profiles in enumerate(st.session_state.unmatched_results, start=1):
+
+            st.markdown(
+                f"{idx}, {profiles.get('fullName', 'Unknown')} - {profiles.get('addressWithCountry', 'Unknown')} [LINKEDIN]({profiles.get('linkedinUrl', 'Unknown')})"
+            )
+
+

saral_ai_api.py

@@ -0,0 +1,231 @@
+from flask import Flask, render_template, request, jsonify, session
+import re
+import os
+import json
+import traceback
+from dotenv import load_dotenv
+from openai import AzureOpenAI
+
+# Import your custom modules (make sure these are available)
+try:
+    from nlp_parsed import parse_recruiter_query, prompt_enhancer
+    from SERP import query_making, serp_api_call
+    from apify import apify_call
+    from validate import validate_function, score_candidates
+    from postgres_db import fetch_from_saral_data, check_completeness, data_input, cur, conn, store_prompt
+    MODULES_AVAILABLE = True
+except ImportError as e:
+    print(f"Warning: Some modules not available: {e}")
+    MODULES_AVAILABLE = False
+
+load_dotenv()
+
+app = Flask(__name__)
+app.secret_key = os.getenv('SECRET_KEY', 'your-secret-key-here')
+
+# Mock functions for when modules aren't available (for testing)
+def mock_parse_recruiter_query(query):
+    return {
+        "job_title": "Software Engineer",
+        "skills": ["Python", "Flask"],
+        "experience": "3-5",
+        "location": "Mumbai",
+        "work_preference": "Remote",
+        "job_type": "Full-time",
+        "is_indian": True
+    }
+
+def mock_prompt_enhancer(prompt):
+    return f"Enhanced: {prompt} - Looking for skilled professionals"
+
+def mock_query_making(parsed_data):
+    return "https://linkedin.com/search", ["Mumbai", "Delhi"]
+
+def mock_serp_api_call(query, start=0, results_per_page=10):
+    return [f"https://linkedin.com/in/user{i}" for i in range(start, start + results_per_page)]
+
+def mock_fetch_from_saral_data(serp_data, conn):
+    return [], serp_data  # Return empty saral_data, all URLs as remaining
+
+def mock_apify_call(serp_json):
+    mock_profiles = []
+    for i in range(min(5, len(serp_json))):
+        mock_profiles.append({
+            "fullName": f"John Doe {i+1}",
+            "headline": "Software Engineer with 5+ years experience",
+            "addressWithCountry": "Mumbai, India",
+            "email": f"john{i+1}@example.com",
+            "linkedinUrl": f"https://linkedin.com/in/johndoe{i+1}",
+            "skills": [{"title": "Python"}, {"title": "Flask"}, {"title": "JavaScript"}],
+            "about": "Experienced software developer with expertise in web technologies...",
+            "experiences": [
+                {
+                    "title": "Senior Software Engineer",
+                    "subtitle": "Tech Company",
+                    "caption": "Jan 2020 - Present",
+                    "description": [{"text": "Developed web applications using Python and Flask"}]
+                }
+            ],
+            "profilePic": "https://via.placeholder.com/150",
+            "is_complete": "Complete Profile"
+        })
+    return mock_profiles
+
+def mock_validate_function(location, candidates):
+    # Split candidates into matched and unmatched (80% matched, 20% unmatched)
+    split_point = int(len(candidates) * 0.8)
+    return candidates[:split_point], candidates[split_point:]
+
+def mock_score_candidates(parsed_data, candidates):
+    for i, candidate in enumerate(candidates):
+        candidate['score'] = round(85 + (i % 15), 1)  # Scores between 85-100
+    return candidates
+
+def mock_data_input(candidates):
+    pass
+
+def mock_store_prompt(conn, prompt, parsed_data):
+    pass
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+@app.route('/parse_query', methods=['POST'])
+def parse_query():
+    try:
+        data = request.json
+        user_input = data.get('query', '').strip()
+        
+        if not user_input:
+            return jsonify({'error': 'Please enter a valid query'})
+        
+        if MODULES_AVAILABLE:
+            parsed_data = parse_recruiter_query(user_input)
+        else:
+            parsed_data = mock_parse_recruiter_query(user_input)
+        
+        return jsonify({'success': True, 'parsed_data': parsed_data})
+    
+    except Exception as e:
+        return jsonify({'error': f'Error parsing query: {str(e)}'})
+
+@app.route('/enhance_prompt', methods=['POST'])
+def enhance_prompt():
+    try:
+        data = request.json
+        user_input = data.get('query', '').strip()
+        
+        if not user_input:
+            return jsonify({'error': 'Please enter a valid query'})
+        
+        if MODULES_AVAILABLE:
+            enhanced = prompt_enhancer(user_input)
+        else:
+            enhanced = mock_prompt_enhancer(user_input)
+        
+        return jsonify({'success': True, 'enhanced_query': enhanced})
+    
+    except Exception as e:
+        return jsonify({'error': f'Error enhancing prompt: {str(e)}'})
+
+@app.route('/search', methods=['POST'])
+def search():
+    try:
+        data = request.json
+        user_input = data.get('query', '').strip()
+        current_page = data.get('page', 0)
+        
+        if not user_input:
+            return jsonify({'error': 'Please enter a valid query'})
+        
+        # Parse query
+        if MODULES_AVAILABLE:
+            parsed_data = parse_recruiter_query(user_input)
+            print(parsed_data)
+        else:
+            parsed_data = mock_parse_recruiter_query(user_input)
+            print(parsed_data)
+        
+        if "error" in parsed_data:
+            return jsonify({'error': parsed_data["error"]})
+        
+        if parsed_data.get("is_indian") == False:
+            return jsonify({'error': 'Our platform is not allowing search outside of India'})
+        
+        # Store prompt
+        if MODULES_AVAILABLE:
+            store_prompt(conn, user_input, parsed_data)
+        else:
+            mock_store_prompt(None, user_input, parsed_data)
+        
+        # Get query and location
+        if MODULES_AVAILABLE:
+            query, location = query_making(parsed_data)
+            print(query)
+            
+        else:
+            query, location = mock_query_making(parsed_data)
+            print(query)
+            
+        
+        # Pagination
+        results_per_page = 10
+        start = current_page * results_per_page
+        
+        # Get SERP data
+        if MODULES_AVAILABLE:
+            serp_data = serp_api_call(query, start=start, results_per_page=results_per_page)
+            saral_data, remain_urls = fetch_from_saral_data(serp_data, conn)
+        else:
+            serp_data = mock_serp_api_call(query, start=start, results_per_page=results_per_page)
+            saral_data, remain_urls = mock_fetch_from_saral_data(serp_data, None)
+        
+        # Process remaining URLs with Apify
+        apify_json = {}
+        if len(remain_urls) >= 1:
+            serp_json = {idx: url for idx, url in enumerate(remain_urls, start=1)}
+            
+            if MODULES_AVAILABLE:
+                apify_json = apify_call(serp_json)
+            else:
+                apify_json = mock_apify_call(serp_json)
+        
+        # Combine data
+        if apify_json:
+            total_candidates = saral_data + apify_json
+        else:
+            total_candidates = saral_data
+        
+        # Store data
+        if MODULES_AVAILABLE:
+            data_input(total_candidates)
+        else:
+            mock_data_input(total_candidates)
+        
+        # Validate and score
+        if MODULES_AVAILABLE:
+            matched, unmatched = validate_function(location, total_candidates)
+            matched = score_candidates(parsed_data, matched)
+        else:
+            matched, unmatched = mock_validate_function(location, total_candidates)
+            matched = mock_score_candidates(parsed_data, matched)
+        
+        return jsonify({
+            'success': True,
+            'parsed_data': parsed_data,
+            'matched_results': matched,
+            'unmatched_results': unmatched,
+            'current_page': current_page
+        })
+    
+    except Exception as e:
+        print(f"Error in search: {traceback.format_exc()}")
+        return jsonify({'error': f'Search error: {str(e)}'})
+
+# if __name__ == '__main__':
+#     # Ensure templates directory exists
+#     if not os.path.exists('templates'):
+#         os.makedirs('templates')
+    
+#     app.run(debug=True, host='0.0.0.0', port=5000)

templates/index.html

@@ -0,0 +1,673 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Saral AI - LinkedIn Recruiter Assistant</title>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.2/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+    <!-- <link rel="icon" type="image/x-icon" href="{{ url_for('static', filename='favicon.ico') }}"> -->
+    <style>
+        :root {
+            --primary-color: #0077b5;
+            --secondary-color: #00a0dc;
+            --success-color: #28a745;
+            --warning-color: #ffc107;
+            --error-color: #dc3545;
+            --dark-color: #2c3e50;
+            --light-bg: #f8f9fa;
+        }
+
+        body {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+
+        .main-container {
+            background: white;
+            margin: 20px auto;
+            border-radius: 20px;
+            box-shadow: 0 15px 35px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+
+        .header {
+            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
+            color: white;
+            padding: 30px;
+            text-align: center;
+        }
+
+        .header h1 {
+            margin: 0;
+            font-size: 2.5rem;
+            font-weight: bold;
+        }
+
+        .content-area {
+            padding: 40px;
+        }
+
+        .query-input {
+            border: 2px solid #e9ecef;
+            border-radius: 10px;
+            padding: 15px;
+            font-size: 16px;
+            transition: all 0.3s ease;
+            min-height: 120px;
+            resize: vertical;
+        }
+
+        .query-input:focus {
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 0.2rem rgba(0,119,181,0.25);
+        }
+
+        .btn-custom {
+            background: linear-gradient(135deg, var(--primary-color), var(--secondary-color));
+            border: none;
+            padding: 12px 30px;
+            border-radius: 25px;
+            color: white;
+            font-weight: 600;
+            transition: all 0.3s ease;
+            margin: 5px;
+        }
+
+        .btn-custom:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(0,119,181,0.4);
+            color: white;
+        }
+
+        .btn-secondary-custom {
+            background: linear-gradient(135deg, #6c757d, #495057);
+            border: none;
+            padding: 10px 25px;
+            border-radius: 20px;
+            color: white;
+            font-weight: 500;
+            transition: all 0.3s ease;
+            margin: 5px;
+        }
+
+        .btn-secondary-custom:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 5px 15px rgba(108,117,125,0.4);
+            color: white;
+        }
+
+        .query-display {
+            background: var(--light-bg);
+            border-radius: 15px;
+            padding: 25px;
+            margin: 20px 0;
+            border-left: 5px solid var(--primary-color);
+        }
+
+        .profile-card {
+            background: white;
+            border-radius: 15px;
+            padding: 25px;
+            margin: 15px 0;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.08);
+            border: 1px solid #e9ecef;
+            transition: all 0.3s ease;
+        }
+
+        .profile-card:hover {
+            transform: translateY(-5px);
+            box-shadow: 0 10px 25px rgba(0,0,0,0.15);
+        }
+
+        .profile-image {
+            width: 120px;
+            height: 120px;
+            border-radius: 50%;
+            object-fit: cover;
+            border: 4px solid var(--primary-color);
+        }
+
+        .skills-tag {
+            display: inline-block;
+            background: var(--primary-color);
+            color: white;
+            padding: 5px 12px;
+            margin: 3px;
+            border-radius: 15px;
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .experience-item {
+            background: #f8f9fa;
+            padding: 15px;
+            margin: 10px 0;
+            border-radius: 10px;
+            border-left: 4px solid var(--secondary-color);
+        }
+
+        .score-badge {
+            background: linear-gradient(135deg, var(--success-color), #20c997);
+            color: white;
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-weight: bold;
+            font-size: 14px;
+        }
+
+        .loading-spinner {
+            display: none;
+            text-align: center;
+            padding: 20px;
+        }
+
+        .stats-card {
+            background: linear-gradient(135deg, #28a745, #20c997);
+            color: white;
+            padding: 20px;
+            border-radius: 15px;
+            text-align: center;
+            margin: 10px 0;
+        }
+
+        .pagination-controls {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            margin: 30px 0;
+            gap: 15px;
+        }
+
+        .error-message {
+            background: #f8d7da;
+            border: 1px solid #f5c6cb;
+            color: #721c24;
+            padding: 15px;
+            border-radius: 10px;
+            margin: 20px 0;
+        }
+
+        .success-message {
+            background: #d4edda;
+            border: 1px solid #c3e6cb;
+            color: #155724;
+            padding: 15px;
+            border-radius: 10px;
+            margin: 20px 0;
+        }
+
+        .unmatched-list {
+            background: #fff3cd;
+            border: 1px solid #ffeaa7;
+            padding: 20px;
+            border-radius: 15px;
+            margin-top: 30px;
+        }
+
+        .progress-bar-custom {
+            background: linear-gradient(90deg, var(--primary-color), var(--secondary-color));
+            height: 20px;
+            border-radius: 10px;
+            transition: width 0.3s ease;
+        }
+
+        @media (max-width: 768px) {
+            .content-area {
+                padding: 20px;
+            }
+            .header h1 {
+                font-size: 2rem;
+            }
+            .profile-card {
+                padding: 15px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container-fluid">
+        <div class="main-container">
+            <div class="header">
+                <h1><i class="fas fa-search"></i> Saral AI</h1>
+                <p class="mb-0">LinkedIn Recruiter Assistant</p>
+            </div>
+
+            <div class="content-area">
+                <div class="row">
+                    <div class="col-12">
+                        <div class="mb-4">
+                            <label for="queryInput" class="form-label h5">Enter your recruitment query:</label>
+                            <textarea 
+                                id="queryInput" 
+                                class="form-control query-input" 
+                                placeholder="e.g., Looking for Python developers with 3-5 years experience in Mumbai..."
+                                rows="4"></textarea>
+                        </div>
+
+                        <div class="text-center mb-4">
+                            <button class="btn btn-secondary-custom" onclick="enhancePrompt()">
+                                <i class="fas fa-magic"></i> Enhance Prompt
+                            </button>
+                            <button class="btn btn-custom" onclick="searchCandidates()" id="searchBtn">
+                                <i class="fas fa-play"></i> Enter
+                            </button>
+                        </div>
+
+                        <div class="loading-spinner" id="loadingSpinner">
+                            <div class="spinner-border text-primary" role="status">
+                                <span class="visually-hidden">Loading...</span>
+                            </div>
+                            <p class="mt-2">Searching for candidates...</p>
+                            <div class="progress mt-3" style="height: 20px;">
+                                <div class="progress-bar progress-bar-custom" id="progressBar" 
+                                     role="progressbar" style="width: 0%"></div>
+                            </div>
+                        </div>
+
+                        <div id="errorMessage" class="error-message" style="display: none;"></div>
+                        <div id="successMessage" class="success-message" style="display: none;"></div>
+
+                        <div id="queryDisplay" class="query-display" style="display: none;">
+                            <h5><i class="fas fa-info-circle"></i> Parsed Query Information</h5>
+                            <div class="row" id="queryDetails"></div>
+                        </div>
+
+                        <div id="resultsStats" style="display: none;">
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <div class="stats-card">
+                                        <h3 id="matchedCount">0</h3>
+                                        <p class="mb-0">Matched Profiles</p>
+                                    </div>
+                                </div>
+                                <div class="col-md-6">
+                                    <div class="stats-card" style="background: linear-gradient(135deg, #ffc107, #fd7e14);">
+                                        <h3 id="unmatchedCount">0</h3>
+                                        <p class="mb-0">Unmatched Profiles</p>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+
+                        <div class="pagination-controls" id="paginationControls" style="display: none;">
+                            <button class="btn btn-secondary-custom" onclick="previousPage()" id="prevBtn">
+                                <i class="fas fa-chevron-left"></i> Previous
+                            </button>
+                            <span id="pageInfo" class="mx-3 fw-bold">Page 1</span>
+                            <button class="btn btn-secondary-custom" onclick="nextPage()" id="nextBtn">
+                                Next <i class="fas fa-chevron-right"></i>
+                            </button>
+                        </div>
+
+                        <div id="candidateResults"></div>
+
+                        <div id="unmatchedResults" class="unmatched-list" style="display: none;">
+                            <h5><i class="fas fa-exclamation-triangle"></i> Unmatched Profiles</h5>
+                            <div id="unmatchedList"></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.2/js/bootstrap.bundle.min.js"></script>
+    <script>
+        let currentPage = 0;
+        let currentQuery = '';
+        let currentResults = {
+            matched: [],
+            unmatched: [],
+            parsed_data: {}
+        };
+
+        function showError(message) {
+            const errorDiv = document.getElementById('errorMessage');
+            errorDiv.innerHTML = `<i class="fas fa-exclamation-triangle"></i> ${message}`;
+            errorDiv.style.display = 'block';
+            document.getElementById('successMessage').style.display = 'none';
+        }
+
+        function showSuccess(message) {
+            const successDiv = document.getElementById('successMessage');
+            successDiv.innerHTML = `<i class="fas fa-check-circle"></i> ${message}`;
+            successDiv.style.display = 'block';
+            document.getElementById('errorMessage').style.display = 'none';
+        }
+
+        function hideMessages() {
+            document.getElementById('errorMessage').style.display = 'none';
+            document.getElementById('successMessage').style.display = 'none';
+        }
+
+        function showLoading() {
+            document.getElementById('loadingSpinner').style.display = 'block';
+            document.getElementById('searchBtn').disabled = true;
+        }
+
+        function hideLoading() {
+            document.getElementById('loadingSpinner').style.display = 'none';
+            document.getElementById('searchBtn').disabled = false;
+        }
+
+        function updateProgress(percentage) {
+            document.getElementById('progressBar').style.width = percentage + '%';
+        }
+
+        async function enhancePrompt() {
+            const query = document.getElementById('queryInput').value.trim();
+            if (!query) {
+                showError('Please enter a query first');
+                return;
+            }
+
+            try {
+                const response = await fetch('/enhance_prompt', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ query })
+                });
+
+                const data = await response.json();
+                if (data.success) {
+                    document.getElementById('queryInput').value = data.enhanced_query;
+                    showSuccess('Prompt enhanced successfully!');
+                } else {
+                    showError(data.error || 'Failed to enhance prompt');
+                }
+            } catch (error) {
+                showError('Error enhancing prompt: ' + error.message);
+            }
+        }
+
+        function displayParsedQuery(parsedData) {
+            const queryDetails = document.getElementById('queryDetails');
+            queryDetails.innerHTML = `
+                <div class="col-md-6">
+                    <p><strong>Job Title:</strong> ${parsedData.job_title || 'None'}</p>
+                    <p><strong>Skills:</strong> ${Array.isArray(parsedData.skills) ? parsedData.skills.join(', ') : parsedData.skills || 'None'}</p>
+                    <p><strong>Experience:</strong> ${parsedData.experience || 'None'} years</p>
+                    <p><strong>Indian Candidate:</strong> ${parsedData.is_indian ? 'Yes' : 'No'}</p>
+                </div>
+                <div class="col-md-6">
+                    <p><strong>Location:</strong> ${parsedData.location || 'None'}</p>
+                    <p><strong>Work Preference:</strong> ${parsedData.work_preference || 'None'}</p>
+                    <p><strong>Job Type:</strong> ${parsedData.job_type || 'None'}</p>
+                </div>
+            `;
+            document.getElementById('queryDisplay').style.display = 'block';
+        }
+
+        async function searchCandidates() {
+            const query = document.getElementById('queryInput').value.trim();
+            if (!query) {
+                showError('Please enter a query first');
+                return;
+            }
+
+            currentQuery = query;
+            currentPage = 0; // Reset to first page
+            showLoading();
+            hideMessages();
+            updateProgress(0);
+
+            try {
+                // First parse the query
+                updateProgress(10);
+                const parseResponse = await fetch('/parse_query', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ query })
+                });
+
+                const parseData = await parseResponse.json();
+                if (!parseData.success) {
+                    throw new Error(parseData.error || 'Failed to parse query');
+                }
+
+                // Check if query is for Indian candidates
+                if (parseData.parsed_data.is_indian === false) {
+                    throw new Error('Our platform only supports searches for candidates in India');
+                }
+
+                displayParsedQuery(parseData.parsed_data);
+                updateProgress(30);
+
+                // Now search for candidates
+                const response = await fetch('/search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ 
+                        query: query,
+                        parsed_data: parseData.parsed_data,
+                        page: currentPage 
+                    })
+                });
+
+                updateProgress(70);
+
+                const data = await response.json();
+                if (data.success) {
+                    currentResults = data;
+                    displayResults(data);
+                    updateProgress(100);
+                    showSuccess(`Search completed! Found ${data.matched_results.length} matched profiles.`);
+                } else {
+                    throw new Error(data.error || 'Search failed');
+                }
+            } catch (error) {
+                showError('Error during search: ' + error.message);
+            } finally {
+                hideLoading();
+            }
+        }
+
+        function displayResults(data) {
+            // Display stats
+            document.getElementById('matchedCount').textContent = data.matched_results.length;
+            document.getElementById('unmatchedCount').textContent = data.unmatched_results.length;
+            document.getElementById('resultsStats').style.display = 'block';
+
+            // Display pagination
+            updatePagination();
+
+            // Display matched results
+            displayCandidates(data.matched_results);
+
+            // Display unmatched results
+            displayUnmatchedCandidates(data.unmatched_results);
+        }
+
+        function updatePagination() {
+            document.getElementById('pageInfo').textContent = `Page ${currentPage + 1}`;
+            document.getElementById('paginationControls').style.display = 'flex';
+            document.getElementById('prevBtn').disabled = currentPage === 0;
+        }
+
+        function displayCandidates(candidates) {
+            const resultsDiv = document.getElementById('candidateResults');
+            if (!candidates || candidates.length === 0) {
+                resultsDiv.innerHTML = '<div class="text-center"><h5>No matched candidates found</h5></div>';
+                return;
+            }
+
+            let html = '<h4><i class="fas fa-users"></i> Candidate Profiles</h4>';
+            
+            candidates.forEach((candidate, index) => {
+                const skills = Array.isArray(candidate.skills) 
+                    ? candidate.skills.map(s => typeof s === 'object' ? s.title : s).slice(0, 10)
+                    : [];
+                
+                const experiences = candidate.experiences || [];
+                const isOpenToWork = !experiences.some(exp => 
+                    exp.caption && exp.caption.includes('Present')
+                );
+
+                const defaultImage = "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRDVO09x_DXK3p4Mt1j08Ab0R875TdhsDcG2A&s";
+
+                html += `
+                    <div class="profile-card">
+                        <div class="row">
+                            <div class="col-md-3 text-center">
+                                <img src="${candidate.profilePic || defaultImage}" 
+                                     alt="Profile" class="profile-image mb-3">
+                                <div class="score-badge mb-2">
+                                    Score: ${candidate.score || 'N/A'}
+                                </div>
+                                <p><strong>Location:</strong><br>${candidate.addressWithCountry || 'N/A'}</p>
+                                <p><strong>Email:</strong><br>${candidate.email || 'None'}</p>
+                                <p><strong>Open to Work:</strong><br>${isOpenToWork ? 'True' : 'False'}</p>
+                                ${candidate.linkedinUrl ? `
+                                    <a href="${candidate.linkedinUrl}" target="_blank" class="btn btn-custom btn-sm">
+                                        <i class="fab fa-linkedin"></i> LinkedIn
+                                    </a>
+                                ` : ''}
+                            </div>
+                            <div class="col-md-9">
+                                <h4>${candidate.fullName || 'Unknown'}</h4>
+                                ${candidate.headline ? `<p class="text-muted fst-italic">${candidate.headline}</p>` : ''}
+                                
+                                ${skills.length > 0 ? `
+                                    <div class="mb-3">
+                                        <strong>Skills:</strong><br>
+                                        ${skills.map(skill => `<span class="skills-tag">${skill}</span>`).join('')}
+                                    </div>
+                                ` : ''}
+
+                                ${candidate.about ? `
+                                    <div class="mb-3">
+                                        <strong>About:</strong>
+                                        <p>${candidate.about.length > 250 ? candidate.about.substring(0, 250) + '...' : candidate.about}</p>
+                                    </div>
+                                ` : ''}
+
+                                ${experiences.length > 0 ? `
+                                    <div class="mb-3">
+                                        <strong>Experience:</strong>
+                                        ${experiences.map(exp => `
+                                            <div class="experience-item">
+                                                <strong>${exp.title || ''}</strong> at <strong>${exp.subtitle || exp.metadata || ''}</strong>
+                                                <small class="text-muted d-block">${exp.caption || ''}</small>
+                                                ${exp.description && exp.description.length > 0 ? `
+                                                    <ul class="mt-2">
+                                                        ${exp.description.map(desc => 
+                                                            typeof desc === 'object' && desc.text ? 
+                                                            `<li>${desc.text}</li>` : ''
+                                                        ).join('')}
+                                                    </ul>
+                                                ` : ''}
+                                            </div>
+                                        `).join('')}
+                                    </div>
+                                ` : ''}
+
+                                ${candidate.is_complete ? `
+                                    <div class="text-success">
+                                        <i class="fas fa-check-circle"></i> ${candidate.is_complete}
+                                    </div>
+                                ` : ''}
+                            </div>
+                        </div>
+                    </div>
+                `;
+            });
+
+            resultsDiv.innerHTML = html;
+        }
+
+        function displayUnmatchedCandidates(unmatchedCandidates) {
+            const unmatchedDiv = document.getElementById('unmatchedResults');
+            const unmatchedList = document.getElementById('unmatchedList');
+            
+            if (!unmatchedCandidates || unmatchedCandidates.length === 0) {
+                unmatchedDiv.style.display = 'none';
+                return;
+            }
+
+            let html = '';
+            unmatchedCandidates.forEach((candidate, index) => {
+                html += `
+                    <p>${index + 1}. ${candidate.fullName || 'Unknown'} - 
+                    ${candidate.addressWithCountry || 'Unknown'} 
+                    ${candidate.linkedinUrl ? `<a href="${candidate.linkedinUrl}" target="_blank">LINKEDIN</a>` : ''}</p>
+                `;
+            });
+
+            unmatchedList.innerHTML = html;
+            unmatchedDiv.style.display = 'block';
+        }
+
+        async function nextPage() {
+            currentPage++;
+            await searchPage();
+        }
+
+        async function previousPage() {
+            if (currentPage > 0) {
+                currentPage--;
+                await searchPage();
+            }
+        }
+
+        async function searchPage() {
+            if (!currentQuery) return;
+
+            showLoading();
+            hideMessages();
+            updateProgress(0);
+
+            try {
+                updateProgress(30);
+                const response = await fetch('/search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ 
+                        query: currentQuery,
+                        page: currentPage 
+                    })
+                });
+
+                updateProgress(70);
+
+                const data = await response.json();
+                if (data.success) {
+                    currentResults = data;
+                    displayResults(data);
+                    updateProgress(100);
+                    showSuccess(`Page ${currentPage + 1} loaded successfully!`);
+                } else {
+                    throw new Error(data.error || 'Failed to load page');
+                }
+            } catch (error) {
+                showError('Error loading page: ' + error.message);
+                // Revert page on error
+                currentPage = Math.max(0, currentPage - (event.target.textContent.includes('Next') ? 1 : -1));
+            } finally {
+                hideLoading();
+            }
+        }
+
+        // Auto-parse query as user types (optional feature)
+        let parseTimeout;
+        document.getElementById('queryInput').addEventListener('input', function() {
+            clearTimeout(parseTimeout);
+            parseTimeout = setTimeout(() => {
+                const query = this.value.trim();
+                if (query && query.length > 10) {
+                    // You can add auto-parsing here if desired
+                }
+            }, 500);
+        });
+    </script>
+</body>
+</html>

validate.py

@@ -0,0 +1,83 @@
+def validate_function(location,apify_json):  
+      locations = [loc.lower().strip() for loc in location] if location else []
+   
+      if not locations:
+            locations = ["india"]
+
+      
+      match_list = []
+      unmatched_list = []
+      
+      for profile in apify_json:  
+        address = profile.get("addressWithCountry", "")
+
+        if not address:
+            unmatched_list.append(profile)  # no address → unmatched
+            continue
+
+        address_lower = [part.strip().lower() for part in address.split(",")]
+
+        
+        if "india" in address_lower or any("india" in part for part in address_lower):
+            if any(loc in address_lower for loc in locations):
+                match_list.append(profile)
+            else:
+                unmatched_list.append(profile)
+        else:
+            unmatched_list.append(profile)  
+
+
+
+      return match_list , unmatched_list
+            
+      
+
+def score_candidates(parsed_data, matched_list):
+    job_title = parsed_data.get("job_title", "").lower()
+    job_keywords = job_title.split() if job_title else []
+    
+    required_skills = [s.lower() for s in parsed_data.get("skills", [])]
+
+    for profile in matched_list:
+        score = 0
+        breakdown = {}
+
+        # Headline check (count occurrences of each keyword)
+        headline = (profile.get("headline") or "").lower()
+        headline_score = 0
+        for kw in job_keywords:
+            count = headline.count(kw)
+            headline_score += count * 15  # each occurrence worth 15
+        score += headline_score
+        breakdown["headline_match"] = headline_score
+
+        # About check (count occurrences of each keyword)
+        about = (profile.get("about") or "").lower()
+        about_score = 0
+        for kw in job_keywords:
+            count = about.count(kw)
+            about_score += count * 10  # each occurrence worth 10
+        score += about_score
+        breakdown["about_match"] = about_score
+
+        # Skills check (exact match count)
+        profile_skills = [
+            s.get("title", "").lower()
+            for s in profile.get("skills", [])
+            if isinstance(s, dict)
+        ]
+        skill_score = 0
+        for req_skill in required_skills:
+            skill_score += profile_skills.count(req_skill) * 10  # per match worth 10
+        score += skill_score
+        breakdown["skills_match"] = skill_score
+
+        # Cap score at 100
+        profile["score"] = min(round(score), 100)
+        profile["score_breakdown"] = breakdown
+
+    # Sort list in-place by score (highest first)
+    matched_list.sort(key=lambda x: x.get("score", 0), reverse=True)
+
+    return matched_list
+