Initial commit: Job hunting AI agent with Gradio interface

.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment variables
+.env
+.venv
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Logs
+*.log
+
+# Local development
+.DS_Store

README.md

@@ -1,14 +1,218 @@
 ---
-title: Job Hunting Ai
-emoji: 🌍
-colorFrom: yellow
-colorTo: blue
+title: Job Hunting AI Assistant
+emoji: 🔍
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.33.0
+sdk_version: 4.14.0
 app_file: app.py
 pinned: false
 license: mit
-short_description: 'Hybrid Job Search Assistant powered by AI '
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Job Hunting AI Assistant 🔍
+
+This AI-powered tool helps you find different jobs with intelligent filtering and search capabilities using an advanced agent-based architecture.
+
+## 🤖 Agent Architecture
+
+This tool implements a sophisticated multi-agent system:
+
+### Search Agent
+- Handles job discovery and initial filtering
+- Uses LangChain for agent orchestration
+- Implements MRKL (Modular Reasoning, Knowledge, and Language) architecture
+- Custom output parser for enhanced JSON handling
+- Retry mechanisms with exponential backoff
+
+### Filtering Agent
+- Intelligent salary parsing and normalization
+- Remote work detection using contextual analysis
+- Location-based relevance scoring
+- Experience level matching
+
+### Coordination Layer
+- Asynchronous task handling
+- Thread-safe API key management
+- Result aggregation and deduplication
+- Error recovery and graceful degradation
+
+## 💫 Custom Gradio Components
+
+### Enhanced DataGrid
+- Custom-styled job listings table
+- HTML-enabled cells for interactive links
+- Responsive column sizing
+- Optimized for job search results
+- Built-in sorting capabilities
+
+### API Configuration Section
+```python
+with gr.Group(elem_classes=["api-config-section"]):
+    gr.Markdown("### 🔑 API Configuration")
+    with gr.Row():
+        serp_api_key = gr.Textbox(
+            label="SerpAPI Key",
+            type="password",
+            scale=2
+        )
+        nebius_api_key = gr.Textbox(
+            label="Nebius API Key",
+            type="password",
+            scale=2
+        )
+```
+
+### Status Display Component
+- Real-time search progress updates
+- Custom styling with gradients
+- Animated state transitions
+- Error handling visualization
+
+### Search Interface
+- Custom-designed search parameters
+- Intelligent default suggestions
+- Dynamic example population
+- Responsive layout adaptation
+
+## 🔑 Required API Keys
+
+1. **SerpAPI Key** (Required for all searches)
+   - Get from [SerpAPI](https://serpapi.com)
+   - Free trial available
+   - Used for job searching
+
+2. **Nebius API Key** (Required for Advanced Search)
+   - Get from [Nebius](https://nebius.ai)
+   - Used for AI-powered filtering
+   - Required for advanced search mode
+
+## 🚀 Features
+
+- Multi-agent architecture for intelligent search
+- Custom Gradio components for enhanced UX
+- Thread-safe API key handling
+- Asynchronous search capabilities
+- Intelligent retry mechanisms
+- AI-powered job search and filtering
+- Support for multiple locations
+- Remote work detection
+- Salary information (when available)
+- Experience level filtering
+- Two search modes:
+  - Advanced (AI-Enhanced)
+  - Basic (Fast)
+
+## 📝 How to Use
+
+1. Enter your API keys in the configuration section
+2. Enter a job search query (e.g., "Python Developer")
+3. Choose your preferences:
+   - Experience Level
+   - Location
+   - Remote Only option
+   - Salary Information visibility
+4. Click "Search Jobs"
+5. View results in the table below
+
+## 🔒 Security
+
+Your API keys are:
+- Never stored on our servers
+- Only kept in memory during active searches
+- Cleared after each search
+- Transmitted securely via HTTPS
+- Not visible to other users
+- Thread-safe API key handling
+- Memory-safe key management
+- Request isolation per user session
+- Secure error handling
+
+## 📊 Search Methods
+
+### 🤖 Advanced Search (AI-Enhanced)
+- Uses LLM for intelligent filtering
+- Better understanding of requirements
+- More accurate matching
+- Takes 30-60 seconds
+- Requires both API keys
+- Multi-agent coordination
+- Contextual understanding
+- Parallel search optimization
+- Intelligent result merging
+
+### ⚡ Basic Search (Fast)
+- Direct API-based search
+- Standard filtering
+- Quick results (10-30s)
+- Only requires SerpAPI key
+- Efficient data processing
+- Real-time updates
+- Minimal resource usage
+
+## 🎨 Custom UI Components
+- Enhanced DataGrid for job listings
+- Real-time status indicators
+- Custom-styled API configuration
+- Responsive layout system
+- Animated state transitions
+- Error visualization
+- Progress tracking
+
+## 🔧 Technical Implementation
+- LangChain for agent orchestration
+- Custom MRKL architecture
+- Thread-safe operations
+- Async/await patterns
+- Custom Gradio components
+- Enhanced error handling
+- Intelligent caching
+- Request queuing
+
+## 🌟 Tips
+- Use specific keywords for better results (e.g., "Senior Python Developer" instead of just "Developer")
+- Try different experience levels to see more opportunities
+- Enable "Remote Only" for work-from-home opportunities
+- Use advanced search for complex requirements
+- Include technology stack in your search query
+- Combine multiple skills (e.g., "Python React Developer")
+- Use location filters strategically
+- Check salary information when available
+- Use quotes for exact matches
+- Try both search modes for comprehensive results
+
+## 💻 Hardware Requirements
+This application runs efficiently on CPU-only infrastructure:
+- All AI processing is done via API calls
+- No local model inference
+- Minimal computational requirements
+- Suitable for basic CPU hosting
+
+## 📊 Session Information
+- Current Time: 2025-06-08 19:50:12 UTC
+- Current User: MananShah-007
+- Version: 1.0.0
+- Last Updated: 2025-06-08
+
+## 📜 License
+MIT License
+
+Copyright (c) 2025 MananShah-007
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_api/__init__.py

@@ -0,0 +1,3 @@
+from .serpjob import scrape_job_profile
+
+__all__ = ['scrape_job_profile']

agent_api/serpjob.py

@@ -0,0 +1,352 @@
+# agent_api/serpjob.py 
+import os
+from dotenv import load_dotenv
+import json
+from serpapi import GoogleSearch
+import time
+from typing import List, Dict, Optional, Tuple
+
+load_dotenv()
+
+def test_api_connection(api_key: str = None) -> Tuple[bool, str]:
+    """Test SerpAPI connection with provided key"""
+    try:
+        if not api_key:
+            return False, "API key is required"
+        
+        # Test with minimal query
+        params = {
+            "api_key": api_key,
+            "engine": "google",
+            "q": "test",
+            "num": 1
+        }
+        
+        search = GoogleSearch(params)
+        results = search.get_dict()
+        
+        if "error" in results:
+            return False, f"API Error: {results['error']}"
+            
+        return True, "Connection successful"
+        
+    except Exception as e:
+        return False, f"Connection failed: {str(e)}"
+
+def clean_salary_text(text: str) -> str:
+    """Clean and format salary information"""
+    if not text or text.lower() in ['n/a', 'not specified', '']:
+        return "Not specified"
+    
+    # Clean whitespace
+    cleaned = ' '.join(text.split())
+    
+    # Format common salary terms
+    replacements = {
+        'a year': '/year',
+        'an hour': '/hour', 
+        'a month': '/month',
+        'per year': '/year',
+        'per hour': '/hour',
+        'per month': '/month'
+    }
+    
+    for old, new in replacements.items():
+        cleaned = cleaned.replace(old, new)
+    
+    return cleaned
+
+def is_job_remote(job: Dict) -> bool:
+    """Determine if a job is remote based on various indicators"""
+    
+    # Collect all text fields to analyze
+    text_sources = [
+        job.get("title", ""),
+        job.get("description", ""),
+        job.get("location", ""),
+        job.get("company_name", ""),
+        str(job.get("detected_extensions", {}))
+    ]
+    
+    # Join all text and convert to lowercase
+    full_text = " ".join(text_sources).lower()
+    
+    # Remote work indicators
+    remote_keywords = [
+        "remote", "work from home", "wfh", "virtual",
+        "anywhere", "fully remote", "remote-first", "100% remote",
+        "work remotely", "distributed team", "telecommute",
+        "home-based", "remote position", "flexible location",
+        "work from anywhere", "remote-friendly", "home office"
+    ]
+    
+    return any(keyword in full_text for keyword in remote_keywords)
+
+def scrape_job_profile(query: str, location: str = "Canada", api_key: str = None) -> str:
+    """
+    Scrape job information from Google Jobs using provided SerpAPI key
+    """
+    print(f"\n{'='*50}")
+    print(f"🔍 STARTING JOB SEARCH")
+    print(f"Query: {query}")
+    print(f"Location: {location}")
+    print(f"{'='*50}")
+    
+    try:
+        # Validate API key
+        if not api_key:
+            print("No API key provided")
+            return json.dumps([])
+        
+        # Test API connection first
+        api_connected, api_message = test_api_connection(api_key)
+        if not api_connected:
+            print(f"API Connection Failed: {api_message}")
+            return json.dumps([])
+        
+        print(f"API Connection: {api_message}")
+        
+        # Clean and prepare search query
+        search_query = query.strip()
+        
+        # Add remote keyword if not present
+        if "remote" not in search_query.lower():
+            search_query = f"{search_query} remote"
+        
+        # Location configuration mapping
+        location_settings = {
+            "United States": {"location": "United States", "gl": "us", "hl": "en"},
+            "Canada": {"location": "Canada", "gl": "ca", "hl": "en"},
+            "United Kingdom": {"location": "United Kingdom", "gl": "gb", "hl": "en"},
+            "Australia": {"location": "Australia", "gl": "au", "hl": "en"},
+            "Germany": {"location": "Germany", "gl": "de", "hl": "en"},
+            "Netherlands": {"location": "Netherlands", "gl": "nl", "hl": "en"},
+            "Remote Worldwide": {"location": "", "gl": "us", "hl": "en"}
+        }
+        
+        # Get location settings
+        loc_config = location_settings.get(location, location_settings["Canada"])
+        
+        # Add location to query if not worldwide
+        if location != "Remote Worldwide" and loc_config["location"]:
+            search_query = f"{search_query} in {loc_config['location']}"
+        
+        print(f"📝 Final search query: '{search_query}'")
+        
+        # Build search parameters
+        search_params = {
+            "api_key": api_key,
+            "engine": "google_jobs",
+            "q": search_query,
+            "hl": loc_config["hl"],
+            "gl": loc_config["gl"],
+            "chips": "date_posted:month",
+            "num": 12  # Reasonable number of results
+        }
+        
+        # Add location parameter if specified
+        if loc_config["location"]:
+            search_params["location"] = loc_config["location"]
+        
+        print(f"���� Search parameters:")
+        for key, value in search_params.items():
+            if key != "api_key":  # Don't log API key
+                print(f"   {key}: {value}")
+        
+        # Execute search with retry mechanism
+        max_attempts = 1
+        results = None
+        
+        for attempt in range(max_attempts):
+            try:
+                print(f"Search attempt {attempt + 1}/{max_attempts}")
+                
+                search = GoogleSearch(search_params)
+                results = search.get_dict()
+                
+                # Check for API errors
+                if "error" in results:
+                    error_msg = results["error"]
+                    print(f"API Error on attempt {attempt + 1}: {error_msg}")
+                    
+                    if attempt < max_attempts - 1:
+                        print("⏳ Waiting before retry...")
+                        time.sleep(2 ** attempt)  # Exponential backoff
+                        continue
+                    else:
+                        print("All attempts failed")
+                        return json.dumps([])
+                
+                # Success
+                print(f"Search successful on attempt {attempt + 1}")
+                break
+                
+            except Exception as e:
+                print(f"Attempt {attempt + 1} failed: {str(e)}")
+                if attempt < max_attempts - 1:
+                    print("⏳ Waiting before retry...")
+                    time.sleep(2 ** attempt)
+                    continue
+                else:
+                    print("All search attempts exhausted")
+                    return json.dumps([])
+        
+        # Extract job results
+        raw_jobs = results.get("jobs_results", [])
+        print(f"📊 Raw jobs found: {len(raw_jobs)}")
+        
+        if not raw_jobs:
+            print("No jobs found in search results")
+            return json.dumps([])
+        
+        # Process and filter jobs
+        processed_jobs = []
+        
+        for idx, job in enumerate(raw_jobs):
+            try:
+                print(f"\n Processing job {idx + 1}: {job.get('title', 'Unknown Title')}")
+                
+                # Extract basic information
+                title = job.get("title", "N/A")
+                company = job.get("company_name", "N/A")
+                job_location = job.get("location", "N/A")
+                
+                print(f"   Company: {company}")
+                print(f"   Location: {job_location}")
+                
+                # Extract salary information
+                salary = "Not specified"
+                if job.get("salary_snippet"):
+                    salary = clean_salary_text(job["salary_snippet"].get("text", ""))
+                elif job.get("detected_extensions", {}).get("salary"):
+                    salary = clean_salary_text(job["detected_extensions"]["salary"])
+                
+                print(f"   Salary: {salary}")
+                
+                # Determine if job is remote
+                remote_status = is_job_remote(job)
+                print(f"   Remote: {'Yes' if remote_status else 'No'}")
+                
+                # Extract apply link
+                apply_link = "N/A"
+                
+                # Try multiple sources for apply link
+                if job.get("apply_options") and len(job["apply_options"]) > 0:
+                    apply_link = job["apply_options"][0].get("link", "N/A")
+                elif job.get("share_link"):
+                    apply_link = job["share_link"]
+                elif job.get("link"):
+                    apply_link = job["link"]
+                
+                # Extract posting date
+                posted_date = "Recently"
+                if job.get("detected_extensions", {}).get("posted_at"):
+                    posted_date = job["detected_extensions"]["posted_at"]
+                elif job.get("posted_at"):
+                    posted_date = job["posted_at"]
+                
+                # Create job entry
+                job_entry = {
+                    "title": title,
+                    "company_name": company,
+                    "location": job_location,
+                    "salary": salary,
+                    "remote": "Yes" if remote_status else "No",
+                    "posted_at": posted_date,
+                    "link": apply_link
+                }
+                
+                # Apply filtering logic
+                should_include = False
+                
+                if location == "Remote Worldwide":
+                    # For worldwide remote, only include remote jobs
+                    should_include = remote_status
+                    filter_reason = "remote status" if remote_status else "not remote"
+                else:
+                    # For specific locations, include if matches location OR is remote
+                    location_match = location.lower() in job_location.lower()
+                    should_include = location_match or remote_status
+                    
+                    if location_match and remote_status:
+                        filter_reason = "location match + remote"
+                    elif location_match:
+                        filter_reason = "location match"
+                    elif remote_status:
+                        filter_reason = "remote job"
+                    else:
+                        filter_reason = "no match"
+                
+                if should_include:
+                    processed_jobs.append(job_entry)
+                    print(f" INCLUDED ({filter_reason})")
+                else:
+                    print(f" FILTERED OUT ({filter_reason})")
+                
+            except Exception as e:
+                print(f"Error processing job {idx + 1}: {str(e)}")
+                continue
+        
+        print(f"\n{'='*50}")
+        print(f"📊 FINAL RESULTS")
+        print(f"Raw jobs found: {len(raw_jobs)}")
+        print(f"Jobs after filtering: {len(processed_jobs)}")
+        print(f"{'='*50}")
+        
+        # Sort by posting date (attempt to put recent jobs first)
+        try:
+            processed_jobs.sort(
+                key=lambda x: x.get("posted_at", ""),
+                reverse=True
+            )
+        except:
+            print("⚠️ Could not sort by posting date")
+        
+        # Return results as JSON
+        result_json = json.dumps(processed_jobs, indent=2)
+        print(f"Returning {len(processed_jobs)} jobs")
+        
+        return result_json
+        
+    except Exception as e:
+        print(f"\n CRITICAL ERROR in scrape_job_profile:")
+        print(f"Error: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return json.dumps([])
+
+def quick_test(api_key: str = None):
+    """Quick test function to verify the scraper works"""
+    print("🧪 TESTING SCRAPER")
+    print("="*30)
+    
+    # Test connection first
+    connected, message = test_api_connection(api_key)
+    print(f"Connection test: {message}")
+    
+    if not connected:
+        return False
+    
+    # Test search
+    try:
+        result = scrape_job_profile("Python developer", "Canada", api_key)
+        jobs = json.loads(result)
+        
+        print(f"Test completed: Found {len(jobs)} jobs")
+        if jobs:
+            sample_job = jobs[0]
+            print(f"Sample job: {sample_job['title']} at {sample_job['company_name']}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"Test failed: {str(e)}")
+        return False
+
+# if __name__ == "__main__":
+#     # Only run test if API key is provided
+#     api_key = os.environ.get("SERP_API_KEY")
+#     if api_key:
+#         quick_test(api_key)
+#     else:
+#         print("No API key found in environment variables")

agents/__init__.py

@@ -0,0 +1,3 @@
+from .job_lookup_agent import lookup
+
+__all__ = ['lookup']

agents/job_lookup_agent.py

@@ -0,0 +1,484 @@
+import os
+import sys
+import json
+from typing import Any, Dict, Optional, List
+import re
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from langchain.agents import initialize_agent
+from langchain.agents.types import AgentType
+from langchain_core.tools import Tool
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from langchain.agents.mrkl.output_parser import MRKLOutputParser
+from langchain.agents.mrkl.prompt import FORMAT_INSTRUCTIONS
+from dotenv import load_dotenv
+from langchain.cache import InMemoryCache
+from langchain.globals import set_llm_cache
+
+from agent_api.serpjob import scrape_job_profile
+
+set_llm_cache(InMemoryCache())
+load_dotenv()
+
+def extract_json_from_text(text: str) -> str:
+    """Extract JSON array from text by finding the first [ and last ]"""
+    try:
+        start = text.find('[')
+        end = text.rfind(']') + 1
+        if start != -1 and end != 0:
+            return text[start:end]
+        return "[]"
+    except:
+        return "[]"
+
+class CustomMRKLOutputParser(MRKLOutputParser):
+    """Custom output parser that handles JSON responses better"""
+    
+    def parse(self, text: str) -> Any:
+        try:
+            return super().parse(text)
+        except Exception:
+            cleaned_text = text.strip()
+            
+            if cleaned_text.startswith('[') and cleaned_text.endswith(']'):
+                try:
+                    json.loads(cleaned_text)
+                    from langchain.schema import AgentFinish
+                    return AgentFinish(
+                        return_values={"output": cleaned_text},
+                        log=text
+                    )
+                except json.JSONDecodeError:
+                    pass
+            
+            json_part = extract_json_from_text(cleaned_text)
+            if json_part and json_part != "[]":
+                try:
+                    json.loads(json_part)
+                    from langchain.schema import AgentFinish
+                    return AgentFinish(
+                        return_values={"output": json_part},
+                        log=text
+                    )
+                except json.JSONDecodeError:
+                    pass
+            
+            return super().parse(text)
+
+def lookup(
+    query: str, 
+    location: str = "Canada", 
+    remote_only: bool = False,
+    serp_api_key: str = None
+) -> str:
+    """
+    Enhanced direct lookup with API key parameter
+    """
+    try:
+        # Clean the query
+        query = query.strip()
+        if "in" in query and location.lower() in query.lower():
+            query = query.replace(f"in {location}", "").replace(f"In {location}", "").strip()
+        
+        print(f"🔍 Direct Lookup: Searching for '{query}' in {location} (Remote only: {remote_only})")
+        
+        # Use the provided API key for the search
+        result = scrape_job_profile(query, location, serp_api_key)
+        
+        # Validate result
+        if not result:
+            print("No results from scrape_job_profile")
+            return "[]"
+        
+        try:
+            jobs_data = json.loads(result)
+            if not isinstance(jobs_data, list):
+                print("Result is not a list format")
+                return "[]"
+            
+            print(f"Found {len(jobs_data)} jobs")
+            return json.dumps(jobs_data)
+            
+        except json.JSONDecodeError as e:
+            print(f"JSON decode error in lookup: {e}")
+            return "[]"
+        
+    except Exception as e:
+        print(f"Error in lookup function: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return "[]"
+
+def lookup_with_llm(
+    query: str, 
+    location: str = "Canada", 
+    remote: bool = False,
+    level: str = "Senior",
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> str:
+    """
+    Enhanced LLM lookup function with API key parameters
+    """
+    try:
+        if not nebius_api_key:
+            print("Nebius API key is required for LLM search")
+            return "[]"
+            
+        llm = ChatOpenAI(
+            temperature=0.1,
+            model_name="meta-llama/Meta-Llama-3.1-405B-Instruct",
+            api_key=nebius_api_key,
+            base_url="https://api.studio.nebius.com/v1/",
+            max_retries=1,
+        )
+
+        # Clean the query
+        query = query.strip()
+        if "in" in query and location.lower() in query.lower():
+            query = query.replace(f"in {location}", "").replace(f"In {location}", "").strip()
+
+        print(f"🤖 LLM Agent: Searching for '{query}' | Location: '{location}' | Remote: {remote} | Level: {level}")
+
+        # Create tool that uses provided SerpAPI key
+        def job_search_tool(q: str) -> str:
+            return lookup(q, location, remote, serp_api_key)
+
+        tools_for_agent = [
+            Tool(
+                name="JobSearch",
+                func=job_search_tool,
+                description=f"Searches for {level} level {query} jobs. {'ONLY returns remote work opportunities.' if remote else f'Returns jobs in {location} plus remote opportunities.'}"
+            )
+        ]
+
+        # Enhanced prompt with clearer filtering instructions
+        remote_instruction = (
+            "MUST return ONLY remote work opportunities, work-from-home positions, and distributed team roles. NO on-site positions."
+            if remote else 
+            f"Return jobs in {location} area that allow working from {location}. Include both on-site and hybrid positions."
+        )
+
+        template = """You are an expert job search assistant. Use the JobSearch tool to find jobs matching the exact criteria specified.
+
+SEARCH CRITERIA:
+- Position: {level} {input}
+- Location Preference: {location}
+- Remote Only: {remote_required}
+- Filtering Rule: {remote_instruction}
+
+IMPORTANT FILTERING RULES:
+1. The JobSearch tool will automatically apply location and remote filtering
+2. Remote jobs can be worked from anywhere, so they should be included unless location is very specific
+3. On-site jobs should only be included if they match the target location
+4. Trust the tool's filtering - it has been enhanced to handle these cases properly
+
+INSTRUCTIONS:
+1. Use the JobSearch tool with the query: "{input}"
+2. The tool automatically applies the filtering based on the specified criteria
+3. Return the complete JSON array from the tool without any modifications
+
+FORMAT:
+Thought: I need to search for jobs with the specified criteria and filtering.
+Action: JobSearch
+Action Input: {input}
+Observation: [tool results will be properly filtered]
+Thought: The tool has returned filtered results. I'll return them exactly as provided.
+Final Answer: [return the exact JSON array from the tool]
+
+CRITICAL: Your Final Answer must be ONLY the JSON array starting with [ and ending with ]. No explanations or additional text.
+
+{format_instructions}"""
+
+        prompt = PromptTemplate(
+            template=template,
+            input_variables=["input", "level", "location", "remote_required", "remote_instruction"],
+            partial_variables={"format_instructions": FORMAT_INSTRUCTIONS}
+        )
+
+        # Initialize agent
+        agent = initialize_agent(
+            tools=tools_for_agent,
+            llm=llm,
+            agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+            verbose=True,
+            handle_parsing_errors=True,
+            max_iterations=3,
+            early_stopping_method="generate",
+            agent_kwargs={
+                "output_parser": CustomMRKLOutputParser(),
+                "format_instructions": FORMAT_INSTRUCTIONS
+            }
+        )
+
+        # Build search query
+        search_query = f"{level} {query}"
+            
+        print(f"🤖 LLM Agent: Executing search with query: '{search_query}'")
+        
+        # Execute agent
+        result = agent.invoke({
+            "input": prompt.format(
+                input=search_query,
+                level=level,
+                location=location,
+                remote_required="YES" if remote else "NO",
+                remote_instruction=remote_instruction
+            )
+        })
+
+        # Process result
+        output = result.get("output", "")
+        print(f"🤖 LLM Agent: Raw output type: {type(output)}")
+
+        if isinstance(output, str):
+            cleaned_output = output.strip()
+            
+            # Remove common prefixes
+            prefixes_to_remove = ["Final Answer:", "Answer:", "Result:"]
+            for prefix in prefixes_to_remove:
+                if cleaned_output.startswith(prefix):
+                    cleaned_output = cleaned_output[len(prefix):].strip()
+            
+            # Extract JSON
+            json_result = extract_json_from_text(cleaned_output)
+            
+            try:
+                jobs_data = json.loads(json_result)
+                if isinstance(jobs_data, list):
+                    print(f"🤖 LLM Agent: Successfully returned {len(jobs_data)} filtered jobs")
+                    return json_result
+                else:
+                    print("🤖 LLM Agent: Result is not a list")
+                    return "[]"
+            except json.JSONDecodeError as e:
+                print(f"🤖 LLM Agent: JSON decode error: {e}")
+                return "[]"
+        else:
+            print(f"🤖 LLM Agent: Unexpected output type: {type(output)}")
+            return "[]"
+
+    except Exception as e:
+        print(f"🤖 Error during LLM job search: {e}")
+        import traceback
+        traceback.print_exc()
+        
+        # FALLBACK: Try the direct lookup method
+        print("🔄 Falling back to direct lookup method...")
+        try:
+            return lookup(query, location, remote, serp_api_key)
+        except Exception as fallback_error:
+            print(f"🤖 Fallback also failed: {fallback_error}")
+            return "[]"
+
+def advanced_job_search(
+    query: str,
+    location: str = "Canada",
+    remote: bool = False,  
+    level: str = "Senior",
+    use_llm: bool = True,
+    salary_min: Optional[int] = None,
+    job_type: Optional[str] = None,
+    company_size: Optional[str] = None,
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> Dict[str, Any]:
+    """
+    Advanced job search function with API key parameters
+    """
+    try:
+        print(f"🚀 Advanced Job Search Started")
+        print(f"Query: '{query}' | Location: '{location}' | Level: {level} | Remote: {remote}")
+        print(f"Salary Min: {salary_min} | Job Type: {job_type} | Company Size: {company_size}")
+        
+        # Validate required API keys
+        if not serp_api_key:
+            return {
+                "success": False,
+                "error": "SerpAPI key is required",
+                "total_found": 0,
+                "jobs": [],
+                "raw_results": "[]"
+            }
+            
+        if use_llm and not nebius_api_key:
+            return {
+                "success": False,
+                "error": "Nebius API key is required for advanced search",
+                "total_found": 0,
+                "jobs": [],
+                "raw_results": "[]"
+            }
+        
+        # Choose search method
+        if use_llm:
+            raw_results = lookup_with_llm(
+                query=query,
+                location=location,
+                remote=remote,
+                level=level,
+                serp_api_key=serp_api_key,
+                nebius_api_key=nebius_api_key
+            )
+        else:
+            raw_results = lookup(
+                query=query,
+                location=location,
+                remote_only=remote,
+                serp_api_key=serp_api_key
+            )
+        
+        # Parse results
+        try:
+            jobs_data = json.loads(raw_results)
+        except json.JSONDecodeError:
+            jobs_data = []
+        
+        print(f"📊 Initial results: {len(jobs_data)} jobs")
+        
+        # Apply additional filters
+        filtered_jobs = []
+        for job in jobs_data:
+            if not isinstance(job, dict):
+                continue
+            
+            # Salary filter
+            if salary_min:
+                job_salary = job.get('salary', '')
+                if job_salary and isinstance(job_salary, str) and job_salary.lower() != 'n/a':
+                    salary_numbers = re.findall(r'\d+', job_salary.replace(',', ''))
+                    if salary_numbers:
+                        max_salary = max([int(x) for x in salary_numbers if len(x) >= 4])
+                        if max_salary < salary_min:
+                            print(f"   💰 Filtered out: {job.get('title', 'N/A')} (salary: {max_salary} < {salary_min})")
+                            continue
+                        else:
+                            print(f"   💰 Included: {job.get('title', 'N/A')} (salary: {max_salary} >= {salary_min})")
+            
+            # Job type filter
+            if job_type and job_type.lower() != 'all':
+                job_title = job.get('title', '').lower()
+                if job_type.lower() not in job_title:
+                    print(f"   🏷️ Filtered out: {job.get('title', 'N/A')} (type mismatch)")
+                    continue
+                else:
+                    print(f"   🏷️ Included: {job.get('title', 'N/A')} (type match)")
+            
+            filtered_jobs.append(job)
+        
+        # Prepare response
+        response = {
+            "success": True,
+            "total_found": len(filtered_jobs),
+            "search_parameters": {
+                "query": query,
+                "location": location,
+                "remote": remote,
+                "level": level,
+                "salary_min": salary_min,
+                "job_type": job_type,
+                "company_size": company_size,
+                "method": "LLM Agent" if use_llm else "Direct Search"
+            },
+            "jobs": filtered_jobs,
+            "raw_results": json.dumps(filtered_jobs),
+            "filtering_applied": {
+                "location_filter": True,
+                "remote_filter": remote,
+                "salary_filter": salary_min is not None,
+                "job_type_filter": job_type is not None and job_type.lower() != 'all',
+                "duplicate_removal": True
+            }
+        }
+        
+        print(f"🎯 Advanced Search Complete: Found {len(filtered_jobs)} matching jobs after all filters")
+        return response
+        
+    except Exception as e:
+        print(f"❌ Advanced job search failed: {e}")
+        import traceback
+        traceback.print_exc()
+        
+        return {
+            "success": False,
+            "error": str(e),
+            "total_found": 0,
+            "jobs": [],
+            "raw_results": "[]",
+            "filtering_applied": {}
+        }
+
+# Convenience functions with API key parameters
+def search_jobs(
+    query: str,
+    location: str = "Canada",
+    remote: bool = False,
+    level: str = "Senior",
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> str:
+    """
+    Main job search function with API key parameters
+    """
+    print(f"🔍 Main Search: '{query}' | Location: '{location}' | Remote: {remote} | Level: {level}")
+    
+    if not location or location.strip() == "":
+        location = "Canada"
+    
+    if not serp_api_key:
+        return "[]"
+        
+    # Use LLM agent if Nebius key is provided
+    if nebius_api_key:
+        return lookup_with_llm(
+            query=query,
+            location=location,
+            remote=remote,
+            level=level,
+            serp_api_key=serp_api_key,
+            nebius_api_key=nebius_api_key
+        )
+    else:
+        return lookup(
+            query=query,
+            location=location,
+            remote_only=remote,
+            serp_api_key=serp_api_key
+        )
+
+# Helper functions with API key parameters
+def search_remote_jobs(
+    query: str,
+    level: str = "Senior",
+    location: str = "Canada",
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> str:
+    """Quick search for remote jobs ONLY"""
+    return lookup_with_llm(
+        query=query,
+        location=location,
+        remote=True,
+        level=level,
+        serp_api_key=serp_api_key,
+        nebius_api_key=nebius_api_key
+    )
+
+def search_entry_level_jobs(
+    query: str,
+    location: str = "Canada",
+    remote: bool = False,
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> str:
+    """Quick search for entry-level positions"""
+    return lookup_with_llm(
+        query=query,
+        location=location,
+        remote=remote,
+        level="Junior",
+        serp_api_key=serp_api_key,
+        nebius_api_key=nebius_api_key
+    )

app.py

@@ -0,0 +1,568 @@
+# app.py
+import os
+import sys
+import json
+import gradio as gr
+import threading
+from typing import Dict, Tuple, List
+from datetime import datetime
+
+# Add current directory to path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '.')))
+
+from dotenv import load_dotenv
+load_dotenv()
+
+from agents.job_lookup_agent import search_jobs, advanced_job_search
+
+# Constants
+CURRENT_UTC_TIME = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+CURRENT_USER = "Job Aspirant"
+
+def validate_api_keys(serp_api_key: str = None, nebius_api_key: str = None) -> Tuple[bool, str]:
+    """Validate provided API keys"""
+    if not serp_api_key:
+        return False, "SerpAPI key is required for job searching"
+    if not nebius_api_key:
+        return False, "Nebius API key is required for advanced search"
+    return True, "API keys validated"
+
+def process_search_with_timeout(
+    query: str,
+    include_salary: bool = True,
+    location: str = "Canada",
+    level: str = "Senior",
+    remote: bool = False,  
+    timeout: int = 100,
+    use_llm: bool = True,
+    serp_api_key: str = None,
+    nebius_api_key: str = None
+) -> Tuple[str, List[List]]:
+    """Process job search with timeout and API key handling"""
+    
+    # Validate API keys first
+    if not serp_api_key:
+        return "Please provide your SerpAPI key", []
+    if use_llm and not nebius_api_key:
+        return "Please provide your Nebius API key for advanced search", []
+
+    # Validate input
+    if not query or not query.strip():
+        return "Please enter a search query", []
+
+    # Create a result container
+    result_container = {"status": "Processing...", "data": []}
+    
+    def search_worker():
+        try:
+            # Clean and prepare query
+            search_query = query.strip()
+            
+            print(f"Starting search: {search_query}")
+            print(f"Location: {location}, Remote: {remote}, Level: {level}")
+            print(f"Using {'advanced' if use_llm else 'basic'} method")
+            
+            if use_llm:
+                # Use advanced search with provided API keys
+                search_result = advanced_job_search(
+                    query=search_query,
+                    location=location,
+                    remote=remote,
+                    level=level,
+                    use_llm=True,
+                    serp_api_key=serp_api_key,
+                    nebius_api_key=nebius_api_key
+                )
+                
+                if search_result["success"]:
+                    raw_results = search_result["raw_results"]
+                    jobs_data = search_result["jobs"]
+                else:
+                    result_container["status"] = f"Search failed: {search_result.get('error', 'Unknown error')}"
+                    result_container["data"] = []
+                    return
+            else:
+                # Use basic search with SerpAPI key only
+                raw_results = search_jobs(
+                    query=search_query,
+                    location=location,
+                    remote=remote,
+                    level=level,
+                    serp_api_key=serp_api_key
+                )
+                if not raw_results or raw_results == "[]":
+                    result_container["status"] = "No results found"
+                    result_container["data"] = []
+                    return
+                
+                try:
+                    jobs_data = json.loads(raw_results)
+                except json.JSONDecodeError:
+                    result_container["status"] = "Error parsing results"
+                    result_container["data"] = []
+                    return
+            
+            if not jobs_data:
+                result_container["status"] = "No jobs found matching your criteria"
+                result_container["data"] = []
+                return
+            
+            if not isinstance(jobs_data, list):
+                result_container["status"] = "Invalid data format"
+                result_container["data"] = []
+                return
+            
+            formatted_data = []
+            for job in jobs_data:
+                if not isinstance(job, dict):
+                    continue
+                
+                title = job.get("title") or job.get("job_title") or job.get("Job Title", "N/A")
+                company = job.get("company_name") or job.get("company") or job.get("Company Name", "N/A")
+                job_location = job.get("location") or job.get("Location", "N/A")
+                salary = job.get("salary") or job.get("Salary", "N/A")
+                is_remote = job.get("remote") or job.get("Remote", "No")
+                posted_date = job.get("posted_at") or job.get("posted_date") or job.get("Posted Date", "N/A")
+                apply_link = job.get("link") or job.get("apply_link") or job.get("Apply Link", "#")
+                
+                if apply_link and apply_link != "N/A" and apply_link != "#":
+                    if '<a href="' in apply_link:
+                        apply_link = apply_link.replace('<a href="', '').replace('" target="_blank">Apply</a>', '').replace('"', '')
+                    formatted_link = f'<a href="{apply_link}" target="_blank" style="color: #3b82f6; text-decoration: none; font-weight: 500;">Apply →</a>'
+                else:
+                    formatted_link = "N/A"
+                
+                location_display = job_location
+                if location_display.lower() in ["anywhere", "remote"]:
+                    location_display = "🌍 Remote Worldwide"
+                elif "remote" in location_display.lower():
+                    location_display = f"🏠 {location_display}"
+                
+                remote_status = "No"
+                if str(is_remote).lower() in ["yes", "true", "remote", "1"] or "remote" in job_location.lower():
+                    remote_status = "Yes"
+                
+                row = [
+                    title,
+                    company,
+                    location_display,
+                    salary if include_salary else "",
+                    remote_status,
+                    posted_date,
+                    formatted_link
+                ]
+                
+                # Remove salary column if not requested
+                if not include_salary:
+                    row.pop(3)
+                
+                formatted_data.append(row)
+            
+            result_container["status"] = f"Found {len(formatted_data)} jobs using {'advanced search' if use_llm else 'basic search'}"
+            result_container["data"] = formatted_data
+                
+        except Exception as e:
+            print(f"Search error: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            result_container["status"] = f"Search failed: {str(e)}"
+            result_container["data"] = []
+    
+    # Run search in thread with timeout
+    search_thread = threading.Thread(target=search_worker)
+    search_thread.daemon = True
+    search_thread.start()
+    
+    # Wait for completion or timeout
+    search_thread.join(timeout)
+    
+    if search_thread.is_alive():
+        return "Search timed out. Please try again with a more specific query.", []
+    
+    return result_container["status"], result_container["data"]
+
+def create_interface():
+    """Create Gradio interface with API key configuration"""
+    
+    # Enhanced CSS for better styling
+    css = """
+    /* Container styling */
+    .gradio-container {
+        max-width: 1400px !important;
+        margin: 0 auto !important;
+    }
+    
+    /* API key section styling */
+    .api-config-section {
+        margin-bottom: 20px;
+        padding: 15px;
+        border-radius: 8px;
+        background-color: var(--background-fill-secondary);
+        border: 1px solid var(--border-color-primary);
+    }
+    
+    .api-config-section input[type="password"] {
+        font-family: monospace;
+        letter-spacing: 2px;
+    }
+    
+    /* Status box styling */
+    .status-box {
+        padding: 15px;
+        border-radius: 8px;
+        margin: 15px 0;
+        font-weight: 500;
+        background-color: var(--background-fill-secondary);
+        border: 1px solid var(--border-color-primary);
+    }
+    
+    /* Table styling */
+    .results-table {
+        margin-top: 20px;
+        margin-bottom: 30px;
+    }
+    
+    .results-table table {
+        width: 100% !important;
+        table-layout: auto !important;
+        border-collapse: separate !important;
+        border-spacing: 0 !important;
+    }
+    
+    .results-table th,
+    .results-table td {
+        padding: 12px 8px !important;
+        vertical-align: top !important;
+        word-wrap: break-word !important;
+        white-space: normal !important;
+    }
+    
+    /* Column width optimization */
+    .results-table th:nth-child(1), .results-table td:nth-child(1) { width: 25%; }
+    .results-table th:nth-child(2), .results-table td:nth-child(2) { width: 20%; }
+    .results-table th:nth-child(3), .results-table td:nth-child(3) { width: 15%; }
+    .results-table th:nth-child(4), .results-table td:nth-child(4) { width: 15%; }
+    .results-table th:nth-child(5), .results-table td:nth-child(5) { width: 10%; }
+    .results-table th:nth-child(6), .results-table td:nth-child(6) { width: 10%; }
+    .results-table th:nth-child(7), .results-table td:nth-child(7) { width: 5%; }
+    """
+    
+    theme = gr.themes.Default(
+        primary_hue="blue",
+        secondary_hue="slate",
+        neutral_hue="slate",
+        font=gr.themes.GoogleFont("Inter"),
+    )
+    
+    with gr.Blocks(title="Job Search Assistant", css=css, theme=theme) as interface:
+        # Header
+        with gr.Group(elem_classes=["header-section"]):
+            gr.Markdown("# 🔍 Advanced Job Search Assistant")
+            gr.Markdown("Find software engineering jobs with AI-powered filtering and intelligent search capabilities.")
+        
+        # API Configuration Section
+        with gr.Group(elem_classes=["api-config-section"]):
+            gr.Markdown("### 🔑 API Configuration")
+            gr.Markdown("""
+            This tool requires two API keys to function:
+            1. [SerpAPI](https://serpapi.com) - For job searching (Required)
+            2. [Nebius](https://nebius.ai) - For AI-powered filtering (Required for Advanced Search)
+            
+            Get your API keys from the links above.
+            """)
+            
+            with gr.Row():
+                serp_api_key = gr.Textbox(
+                    label="SerpAPI Key",
+                    placeholder="Enter your SerpAPI key",
+                    type="password",
+                    value=os.environ.get("SERP_API_KEY", ""),
+                    info="Required for all searches"
+                )
+                nebius_api_key = gr.Textbox(
+                    label="Nebius API Key",
+                    placeholder="Enter your Nebius API key",
+                    type="password",
+                    value=os.environ.get("NEBIUS_API_KEY", ""),
+                    info="Required for advanced AI-powered search"
+                )
+            
+            # API Status Display
+            api_status = gr.Markdown("⚠️ Please enter your API keys to start searching")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input section
+                gr.Markdown("### Search Parameters")
+                
+                search_input = gr.Textbox(
+                    label="Job Title/Keywords",
+                    placeholder="e.g., Python Developer, Full Stack Engineer, DevOps",
+                    lines=2,
+                    info="Enter job title, skills, or keywords"
+                )
+                
+                # Method selection
+                with gr.Group(elem_classes=["method-radio"]):
+                    gr.Markdown("**Search Method Selection**")
+                    search_method = gr.Radio(
+                        choices=["Advanced Search (AI-Enhanced)", "Basic Search (Fast)"],
+                        value="Advanced Search (AI-Enhanced)",
+                        label="Choose Search Method",
+                        info="• Advanced: Uses AI for intelligent parsing and better filtering (30-60s)\n• Basic: Fast search with standard filtering (10-30s)",
+                        show_label=True
+                    )
+                
+                with gr.Row():
+                    exp_level = gr.Dropdown(
+                        choices=["Junior", "Mid-Level", "Senior", "Lead", "Principal"],
+                        value="Senior",
+                        label="Experience Level",
+                        info="Filter by experience level"
+                    )
+                    
+                    location = gr.Dropdown(
+                        choices=[
+                            "Canada", 
+                            "United States", 
+                            "United Kingdom", 
+                            "Australia", 
+                            "Germany",
+                            "Netherlands",
+                            "Remote Worldwide"
+                        ],
+                        value="Canada",
+                        label="Location",
+                        info="Preferred job location"
+                    )
+                
+                with gr.Row():
+                    show_salary = gr.Checkbox(
+                        label="Include Salary Info",
+                        value=True,
+                        info="Show salary information when available"
+                    )
+                    
+                    remote_only = gr.Checkbox(
+                        label="Remote Positions Only",
+                        value=False,
+                        info="Filter ONLY for remote work opportunities"
+                    )
+                
+                search_button = gr.Button(
+                    "🔍 Search Jobs", 
+                    variant="primary",
+                    size="lg"
+                )
+                
+                # Status display
+                status_display = gr.Textbox(
+                    label="Search Status",
+                    interactive=False,
+                    info="Current search status and results count",
+                    elem_classes=["status-box"]
+                )
+        
+        # Results section
+        with gr.Group(elem_classes=["section-gap"]):
+            gr.Markdown("### Search Results")
+            
+            results_table = gr.DataFrame(
+                label="Job Listings",
+                wrap=False,
+                interactive=False,
+                elem_classes=["results-table"],
+                headers=["Job Title", "Company", "Location", "Salary", "Remote", "Posted", "Apply"],
+                datatype=["str", "str", "str", "str", "str", "str", "html"],
+                max_height=600
+            )
+
+        # Search functionality
+        def handle_search(query, method, salary, loc, level, remote, serp_key, nebius_key):
+            if not serp_key:
+                return "Please enter your SerpAPI key", gr.DataFrame(value=[])
+            if method == "Advanced Search (AI-Enhanced)" and not nebius_key:
+                return "Please enter your Nebius API key for advanced search", gr.DataFrame(value=[])
+            
+            if not query or not query.strip():
+                return "Please enter a search query", gr.DataFrame(value=[])
+            
+            # Determine which method to use
+            use_advanced = method == "Advanced Search (AI-Enhanced)"
+            
+            # Show what we're searching for
+            search_info = f"Searching for: '{query}' | Location: {loc} | Level: {level} | Remote Only: {'Yes' if remote else 'No'}"
+            print(search_info)
+            
+            # Perform search with direct API key passing
+            status, data = process_search_with_timeout(
+                query=query,
+                include_salary=salary,
+                location=loc,
+                level=level,
+                remote=remote,
+                timeout=60 if use_advanced else 30,
+                use_llm=use_advanced,
+                serp_api_key=serp_key,
+                nebius_api_key=nebius_key
+            )
+            
+            # Create proper DataFrame with headers
+            if salary:
+                headers = ["Job Title", "Company", "Location", "Salary", "Remote", "Posted", "Apply"]
+                column_types = ["str", "str", "str", "str", "str", "str", "html"]
+            else:
+                headers = ["Job Title", "Company", "Location", "Remote", "Posted", "Apply"]
+                column_types = ["str", "str", "str", "str", "str", "html"]
+            
+            if data:
+                return status, gr.DataFrame(
+                    value=data,
+                    headers=headers,
+                    datatype=column_types
+                )
+            else:
+                return status, gr.DataFrame(
+                    value=[],
+                    headers=headers,
+                    datatype=column_types
+                )
+        
+        # Connect search button
+        search_button.click(
+            fn=handle_search,
+            inputs=[
+                search_input,
+                search_method,
+                show_salary,
+                location,
+                exp_level,
+                remote_only,
+                serp_api_key,
+                nebius_api_key
+            ],
+            outputs=[status_display, results_table],
+            show_progress=True
+        )
+        
+        # Example searches
+        with gr.Group(elem_classes=["example-buttons"]):
+            gr.Markdown("### 🚀 Quick Examples")
+            gr.Markdown("*Click any example to populate the search form*")
+            
+            with gr.Row():
+                example_btn1 = gr.Button("🐍 Python Developer (Remote)", size="sm", variant="secondary")
+                example_btn2 = gr.Button("⚛️ Full Stack Engineer", size="sm", variant="secondary") 
+                example_btn3 = gr.Button("🔧 DevOps Engineer (Senior)", size="sm", variant="secondary")
+                example_btn4 = gr.Button("⚡ React Developer (Entry)", size="sm", variant="secondary")
+        
+        # Example button functions
+        def set_example_1():
+            return "Python Developer", "Advanced Search (AI-Enhanced)", True, "Canada", "Senior", True
+        
+        def set_example_2():
+            return "Full Stack Engineer", "Basic Search (Fast)", True, "United States", "Mid-Level", False
+        
+        def set_example_3():
+            return "DevOps Engineer", "Advanced Search (AI-Enhanced)", False, "Remote Worldwide", "Senior", True
+        
+        def set_example_4():
+            return "React Developer", "Basic Search (Fast)", True, "United Kingdom", "Junior", False
+        
+        # Connect example buttons
+        example_btn1.click(
+            fn=set_example_1,
+            outputs=[search_input, search_method, show_salary, location, exp_level, remote_only]
+        )
+        
+        example_btn2.click(
+            fn=set_example_2,
+            outputs=[search_input, search_method, show_salary, location, exp_level, remote_only]
+        )
+        
+        example_btn3.click(
+            fn=set_example_3,
+            outputs=[search_input, search_method, show_salary, location, exp_level, remote_only]
+        )
+        
+        example_btn4.click(
+            fn=set_example_4,
+            outputs=[search_input, search_method, show_salary, location, exp_level, remote_only]
+        )
+        
+        # API key validation function
+        def validate_keys(serp_key, nebius_key):
+            if not serp_key:
+                return "⚠️ SerpAPI key is required for all searches"
+            if not nebius_key:
+                return "⚠️ Nebius API key is required for advanced search"
+            return "✅ API keys configured"
+        
+        # Connect key validation
+        for key in [serp_api_key, nebius_api_key]:
+            key.change(
+                fn=validate_keys,
+                inputs=[serp_api_key, nebius_api_key],
+                outputs=api_status
+            )
+        
+        # Footer
+        with gr.Group(elem_classes=["footer-info"]):
+            gr.Markdown(f"""
+            ### 📊 Session Information
+            
+            **Current Time:** {CURRENT_UTC_TIME} UTC  
+            **User:** {CURRENT_USER}  
+            
+            ### 🔍 Search Methods
+            
+            **🤖 Advanced Search (AI-Enhanced):**
+            - Uses LLM agents for intelligent job parsing and filtering
+            - Better understanding of remote work requirements
+            - More accurate location and skill matching
+            - Takes 30-60 seconds but provides higher quality results
+            
+            **⚡ Basic Search (Fast):**
+            - Direct API-based search with standard filtering
+            - Quick results in 10-30 seconds
+            - Good for broad searches and quick lookups
+            
+            ### 💡 Tips
+            - Use specific keywords for better results
+            - Enable "Remote Positions Only" for work-from-home opportunities
+            - Advanced search works better for complex requirements
+            - Try different experience levels to see more opportunities
+            
+            ### 🔑 API Key Security
+            Your API keys are:
+            - Never stored on our servers
+            - Only kept in memory during your active search
+            - Cleared after each search
+            - Required for each new search
+            - Transmitted securely via HTTPS
+            - Not visible to other users
+            """)
+    
+    return interface
+
+# Main execution
+if __name__ == "__main__":
+    print("Starting Job Search Application...")
+    print(f"Current time: {CURRENT_UTC_TIME}")
+    
+    try:
+        # Create and launch interface
+        demo = create_interface()
+        
+        # Launch with correct parameters
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True,
+        )
+        
+    except Exception as e:
+        print(f"Failed to start application: {str(e)}")
+        import traceback
+        traceback.print_exc()

requirements.txt

@@ -0,0 +1,26 @@
+# Core LangChain packages
+langchain>=0.1.0
+langchain-core>=0.1.7
+langchain-community>=0.0.10
+langchain-openai>=0.0.8
+
+# API and HTTP related
+openai>=1.3.7
+google-search-results>=2.4.2  
+requests>=2.31.0
+httpx>=0.24.0
+
+# Environment and utils
+python-dotenv>=1.0.0
+pytz>=2023.3
+
+# Type hints and validation
+pydantic>=2.0.0
+pydantic-core>=2.0.0
+typing-extensions>=4.5.0
+
+#gradio
+gradio>=4.14.0
+
+#HF
+huggingface-hub>=0.19.0