Clean up nested package directory structure

tech_radar/cli.py

@@ -13,11 +13,31 @@ def cli():
     pass
 
 @cli.command()
-def seed():
-    """Seed the SQLite database and Vector Store with universal tech job postings."""
-    console.print("[bold green]🌱 Seeding TechRadar Database & Vector Engine...[/bold green]")
+@click.option("--live/--no-live", default=True, help="Fetch real-time live internet jobs from RemoteOK, Jobicy, WWR")
+def seed(live):
+    """Seed SQLite database & Vector Engine with curated + live internet job postings."""
+    console.print(f"[bold green]🌱 Seeding TechRadar Database (Live Scraping: {live})...[/bold green]")
     from tech_radar.scrapers.seeder import seed_database
-    seed_database()
+    seed_database(fetch_live=live)
+
+@cli.command()
+def scrape_live():
+    """Trigger real-time live internet job scraping pipeline."""
+    console.print("[bold cyan]🌐 Executing Live Internet Job Scraper Pipeline...[/bold cyan]")
+    from tech_radar.scrapers.live_scraper import LiveInternetScraper
+    from tech_radar.db.database import DatabaseManager
+    from tech_radar.db.vector_store import SemanticVectorStore
+
+    scraper = LiveInternetScraper()
+    live_jobs = scraper.fetch_all_live_jobs()
+    db = DatabaseManager()
+    for job in live_jobs:
+        db.save_job_posting(job)
+
+    vector_store = SemanticVectorStore()
+    all_jobs = db.get_all_jobs()
+    vector_store.index_jobs(all_jobs)
+    console.print(f"[bold green]✅ Ingested {len(live_jobs)} live jobs! Total jobs in database: {len(all_jobs)}[/bold green]")
 
 @cli.command()
 @click.option("--transport", default="stdio", type=click.Choice(["stdio", "sse"]), help="MCP transport protocol")

tech_radar/scrapers/live_scraper.py

@@ -1,11 +1,20 @@
 import requests
 from bs4 import BeautifulSoup
 import re
-from typing import Optional, Dict, Any, List
+import json
+import warnings
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
 from tech_radar.db.models import JobPosting
 
-class LiveJobScraper:
-    """Extensible Web Scraper Engine for extracting Tech & Software Engineering jobs."""
+warnings.filterwarnings("ignore")
+
+class LiveInternetScraper:
+    """
+    Autonomous Live Internet Job Scraper Engine for TechRadar-MCP.
+    Aggregates live, real-time tech postings from RemoteOK, Jobicy, and WeWorkRemotely feeds.
+    """
 
     def __init__(self):
         self.headers = {
@@ -16,50 +25,248 @@ class LiveJobScraper:
             )
         }
 
-    def scrape_url(self, url: str) -> Optional[JobPosting]:
+    def fetch_all_live_jobs(self) -> List[JobPosting]:
+        """Fetch real-time live jobs from all active internet APIs & feeds."""
+        live_jobs: List[JobPosting] = []
+
+        # 1. Fetch RemoteOK Live API
+        print("[LiveScraper] Ingesting live jobs from RemoteOK API...")
         try:
-            resp = requests.get(url, headers=self.headers, timeout=10)
-            if resp.status_code != 200:
-                return None
-
-            soup = BeautifulSoup(resp.text, "html.parser")
-            title = soup.find("h1") or soup.find("title")
-            title_text = title.get_text(strip=True) if title else "Senior Software Engineer"
-
-            body_text = soup.get_text()
-            extracted_stack = self.extract_tech_keywords(body_text)
-
-            return JobPosting(
-                id=f"LIVE-SCRAPE-{abs(hash(url)) % 10000}",
-                title=title_text[:60],
-                company="Tech Enterprise",
-                tech_domain="Software Engineering",
-                city="Bengaluru",
-                area="Indiranagar",
-                salary_min_lpa=25.0,
-                salary_max_lpa=45.0,
-                experience_min_years=3,
+            remote_ok_jobs = self._scrape_remoteok()
+            live_jobs.extend(remote_ok_jobs)
+            print(f" -> Fetched {len(remote_ok_jobs)} live jobs from RemoteOK.")
+        except Exception as e:
+            print(f"[LiveScraper] RemoteOK error: {e}")
+
+        # 2. Fetch Jobicy Live API
+        print("[LiveScraper] Ingesting live jobs from Jobicy API...")
+        try:
+            jobicy_jobs = self._scrape_jobicy()
+            live_jobs.extend(jobicy_jobs)
+            print(f" -> Fetched {len(jobicy_jobs)} live jobs from Jobicy.")
+        except Exception as e:
+            print(f"[LiveScraper] Jobicy error: {e}")
+
+        # 3. Fetch WeWorkRemotely RSS
+        print("[LiveScraper] Ingesting live jobs from WeWorkRemotely RSS...")
+        try:
+            wwr_jobs = self._scrape_weworkremotely()
+            live_jobs.extend(wwr_jobs)
+            print(f" -> Fetched {len(wwr_jobs)} live jobs from WeWorkRemotely.")
+        except Exception as e:
+            print(f"[LiveScraper] WeWorkRemotely error: {e}")
+
+        print(f"✨ Total Live Internet Jobs Ingested: {len(live_jobs)}")
+        return live_jobs
+
+    def _scrape_remoteok(self) -> List[JobPosting]:
+        url = "https://remoteok.com/api"
+        resp = requests.get(url, headers=self.headers, timeout=12)
+        if resp.status_code != 200:
+            return []
+
+        raw_data = resp.json()
+        jobs = []
+
+        # RemoteOK first item is metadata
+        items = raw_data[1:] if isinstance(raw_data, list) and len(raw_data) > 1 else []
+
+        for item in items:
+            if not isinstance(item, dict) or "position" not in item:
+                continue
+
+            title = item.get("position", "Software Engineer")
+            company = item.get("company", "Tech Company")
+            tags = item.get("tags", [])
+            location = item.get("location", "Remote")
+            desc = item.get("description", title)
+            job_url = item.get("url", "https://remoteok.com")
+            raw_id = item.get("id", str(abs(hash(title + company)) % 100000))
+
+            domain = self.detect_domain(title, tags)
+            city = self.detect_city(location)
+            salary_min, salary_max = self.extract_salary_lpa(item.get("salary_min"), item.get("salary_max"), desc)
+
+            jobs.append(JobPosting(
+                id=f"LIVE-ROK-{raw_id}",
+                title=title[:70],
+                company=company[:50],
+                tech_domain=domain,
+                city=city,
+                area=location[:30] if location else "Remote Hub",
+                salary_min_lpa=salary_min,
+                salary_max_lpa=salary_max,
+                experience_min_years=2,
                 experience_max_years=7,
-                tech_stack=extracted_stack or ["Python", "Docker", "PostgreSQL"],
-                requirements=body_text[:1000],
-                work_mode="Hybrid",
+                tech_stack=tags[:8] if tags else ["Python", "Docker", "API"],
+                requirements=self.clean_html(desc)[:1000],
+                work_mode="Remote" if "remote" in location.lower() or not location else "Hybrid",
+                company_tier="Global Remote / Tech Enterprise",
+                posted_date=datetime.now().strftime("%Y-%m-%d"),
+                url=job_url
+            ))
+
+        return jobs
+
+    def _scrape_jobicy(self) -> List[JobPosting]:
+        url = "https://jobicy.com/api/v2/remote-jobs"
+        resp = requests.get(url, headers=self.headers, timeout=12)
+        if resp.status_code != 200:
+            return []
+
+        raw_data = resp.json().get("jobs", [])
+        jobs = []
+
+        for item in raw_data:
+            title = item.get("jobTitle", "Software Engineer")
+            company = item.get("companyName", "Tech Firm")
+            geo = item.get("jobGeo", "Remote")
+            desc = item.get("jobDescription", title)
+            job_url = item.get("url", "https://jobicy.com")
+            raw_id = item.get("id", str(abs(hash(title + company)) % 100000))
+
+            domain = self.detect_domain(title, [item.get("jobCategory", "")])
+            city = self.detect_city(geo)
+            salary_min, salary_max = self.extract_salary_lpa(None, None, desc)
+
+            jobs.append(JobPosting(
+                id=f"LIVE-JBC-{raw_id}",
+                title=title[:70],
+                company=company[:50],
+                tech_domain=domain,
+                city=city,
+                area=geo[:30] if geo else "Global Remote",
+                salary_min_lpa=salary_min,
+                salary_max_lpa=salary_max,
+                experience_min_years=3,
+                experience_max_years=8,
+                tech_stack=self.extract_tech_keywords(title + " " + desc)[:7],
+                requirements=self.clean_html(desc)[:1000],
+                work_mode="Remote",
                 company_tier="Tech Firm",
-                url=url
-            )
-        except Exception as e:
-            print(f"[LiveJobScraper] Error scraping {url}: {e}")
-            return None
+                posted_date=datetime.now().strftime("%Y-%m-%d"),
+                url=job_url
+            ))
+
+        return jobs
+
+    def _scrape_weworkremotely(self) -> List[JobPosting]:
+        url = "https://weworkremotely.com/categories/remote-programming-jobs.rss"
+        resp = requests.get(url, headers=self.headers, timeout=12)
+        if resp.status_code != 200:
+            return []
+
+        soup = BeautifulSoup(resp.text, "html.parser")
+        items = soup.find_all("item")
+        jobs = []
+
+        for idx, item in enumerate(items):
+            title_node = item.find("title")
+            link_node = item.find("link")
+            desc_node = item.find("description")
+
+            full_title = title_node.get_text() if title_node else "Senior Engineer"
+            job_url = link_node.get_text() if link_node else "https://weworkremotely.com"
+            desc = desc_node.get_text() if desc_node else full_title
+
+            parts = full_title.split(":")
+            if len(parts) > 1:
+                company = parts[0].strip()
+                title = parts[1].strip()
+            else:
+                company = "WeWorkRemotely Tech"
+                title = full_title
+
+            domain = self.detect_domain(title, [])
+            salary_min, salary_max = self.extract_salary_lpa(None, None, desc)
+
+            jobs.append(JobPosting(
+                id=f"LIVE-WWR-{idx + 100}",
+                title=title[:70],
+                company=company[:50],
+                tech_domain=domain,
+                city="Remote",
+                area="Global Remote Hub",
+                salary_min_lpa=salary_min,
+                salary_max_lpa=salary_max,
+                experience_min_years=3,
+                experience_max_years=8,
+                tech_stack=self.extract_tech_keywords(title + " " + desc)[:7],
+                requirements=self.clean_html(desc)[:1000],
+                work_mode="Remote",
+                company_tier="Product Tech Leader",
+                posted_date=datetime.now().strftime("%Y-%m-%d"),
+                url=job_url
+            ))
+
+        return jobs
+
+    def detect_domain(self, title: str, tags: List[str]) -> str:
+        text = (title + " " + " ".join(tags)).lower()
+        if any(w in text for w in ["backend", "go", "java", "spring", "microservice", "python"]):
+            return "Backend Engineering"
+        elif any(w in text for w in ["frontend", "react", "next.js", "vue", "typescript", "ui"]):
+            return "Frontend Engineering"
+        elif any(w in text for w in ["full stack", "fullstack", "full-stack"]):
+            return "Full Stack Engineering"
+        elif any(w in text for w in ["devops", "cloud", "aws", "kubernetes", "k8s", "terraform", "sre"]):
+            return "Cloud & DevOps"
+        elif any(w in text for w in ["data", "spark", "snowflake", "kafka", "pipeline", "sql"]):
+            return "Data Engineering"
+        elif any(w in text for w in ["ai", "genai", "llm", "machine learning", "pytorch", "mcp", "cuda"]):
+            return "AI/ML & GenAI"
+        elif any(w in text for w in ["android", "ios", "flutter", "kotlin", "mobile", "swift"]):
+            return "Mobile Engineering"
+        return "Software Engineering"
+
+    def detect_city(self, location: str) -> str:
+        loc = (location or "").lower()
+        if "bengaluru" in loc or "bangalore" in loc:
+            return "Bengaluru"
+        elif "pune" in loc:
+            return "Pune"
+        elif "hyderabad" in loc:
+            return "Hyderabad"
+        elif "gurgaon" in loc or "delhi" in loc or "ncr" in loc:
+            return "Gurgaon"
+        elif "mumbai" in loc:
+            return "Mumbai"
+        elif "chennai" in loc:
+            return "Chennai"
+        return "Remote"
+
+    def extract_salary_lpa(self, sal_min: Optional[float], sal_max: Optional[float], text: str) -> tuple[float, float]:
+        if sal_min and sal_max and sal_min > 1000:
+            # Convert USD to INR LPA (e.g. $100K = ~85 LPA)
+            min_lpa = round((sal_min * 83.5) / 100000.0, 1)
+            max_lpa = round((sal_max * 83.5) / 100000.0, 1)
+            return max(18.0, min_lpa), max(28.0, max_lpa)
+
+        # Regex search for salary numbers in description
+        match = re.search(r'\$(\d{2,3})k?\s*-\s*\$?(\d{2,3})k', text, re.IGNORECASE)
+        if match:
+            s1 = float(match.group(1)) * 1000
+            s2 = float(match.group(2)) * 1000
+            min_lpa = round((s1 * 83.5) / 100000.0, 1)
+            max_lpa = round((s2 * 83.5) / 100000.0, 1)
+            return max(20.0, min_lpa), max(32.0, max_lpa)
+
+        return 26.0, 44.0
 
     def extract_tech_keywords(self, text: str) -> List[str]:
-        known_keywords = [
+        known = [
             "Go", "Java", "Python", "TypeScript", "React", "Next.js", "Node.js",
             "FastAPI", "Spring Boot", "Docker", "Kubernetes", "AWS", "Terraform",
             "PostgreSQL", "Redis", "Kafka", "Apache Spark", "Snowflake",
             "FastMCP", "MCP", "LangGraph", "PyTorch", "CUDA", "vLLM", "Qdrant",
-            "Kotlin", "Flutter", "Swift"
+            "Kotlin", "Flutter", "Swift", "GraphQL", "gRPC"
         ]
         found = []
-        for kw in known_keywords:
+        for kw in known:
             if re.search(r'\b' + re.escape(kw) + r'\b', text, re.IGNORECASE):
                 found.append(kw)
-        return found
+        return found or ["Python", "Docker", "REST API"]
+
+    def clean_html(self, raw_html: str) -> str:
+        soup = BeautifulSoup(raw_html, "html.parser")
+        return soup.get_text(separator=" ", strip=True)

tech_radar/scrapers/seeder.py

@@ -1,23 +1,36 @@
 from tech_radar.db.database import DatabaseManager
 from tech_radar.db.vector_store import SemanticVectorStore
 from tech_radar.scrapers.mock_data import UNIVERSAL_TECH_JOBS
+from tech_radar.scrapers.live_scraper import LiveInternetScraper
 
-def seed_database(db_path: str = "tech_radar.db") -> tuple[DatabaseManager, SemanticVectorStore]:
-    """Seed SQLite database and vector store with universal tech jobs across India & Remote."""
+def seed_database(db_path: str = "tech_radar.db", fetch_live: bool = True) -> tuple[DatabaseManager, SemanticVectorStore]:
+    """Seed SQLite database and vector store with curated + live real-time internet job postings."""
     db = DatabaseManager(db_path=db_path)
     vector_store = SemanticVectorStore()
 
     count = 0
+    # 1. Seed base curated tech jobs
     for job in UNIVERSAL_TECH_JOBS:
         db.save_job_posting(job)
         count += 1
 
+    # 2. Fetch live real-time internet jobs
+    if fetch_live:
+        try:
+            scraper = LiveInternetScraper()
+            live_jobs = scraper.fetch_all_live_jobs()
+            for l_job in live_jobs:
+                db.save_job_posting(l_job)
+                count += 1
+        except Exception as e:
+            print(f"[Seeder] Live internet scraping warning: {e}")
+
     all_jobs = db.get_all_jobs()
     vector_store.index_jobs(all_jobs)
 
-    print(f" Successfully seeded {count} tech job postings into {db_path}.")
+    print(f" Successfully seeded {count} total job postings into {db_path}.")
     print(f" Indexed {len(all_jobs)} jobs across all domains in Vector Engine.")
     return db, vector_store
 
 if __name__ == "__main__":
-    seed_database()
+    seed_database(fetch_live=True)

tech_radar/tech_radar/__init__.py

@@ -1,6 +0,0 @@
-"""
-TechRadar-MCP: Universal Tech Hiring Intelligence & Model Context Protocol Ecosystem
-"""
-
-__version__ = "1.0.0"
-__author__ = "Tech Radar Team"

tech_radar/tech_radar/agents/evaluator_agent.py

@@ -1,160 +0,0 @@
-from typing import List, Dict, Any
-from tech_radar.db.models import JobPosting, SkillGapReport, ResumePatch, InterviewPrepKit, InterviewQuestion
-from tech_radar.agents.skill_extractor import SkillExtractorAgent
-
-class EvaluatorAgent:
-    """Evaluates candidate profiles against target tech job descriptions, producing ATS patches & interview prep."""
-
-    def __init__(self):
-        self.skill_extractor = SkillExtractorAgent()
-
-    def evaluate_skill_gap(self, resume_text: str, candidate_skills: List[str], job: JobPosting) -> SkillGapReport:
-        resume_lower = resume_text.lower()
-        matched = []
-        missing = []
-
-        for req_skill in job.tech_stack:
-            if any(req_skill.lower() == s.lower() for s in candidate_skills) or req_skill.lower() in resume_lower:
-                matched.append(req_skill)
-            else:
-                missing.append(req_skill)
-
-        total_req = len(job.tech_stack) or 1
-        match_pct = round((len(matched) / total_req) * 100, 1)
-
-        high_priority = missing[:3]
-        action_plan = self.skill_extractor.generate_learning_roadmap(missing)
-
-        return SkillGapReport(
-            target_job_id=job.id,
-            job_title=job.title,
-            company=job.company,
-            city=job.city,
-            tech_domain=job.tech_domain,
-            match_percentage=match_pct,
-            matched_skills=matched,
-            missing_skills=missing,
-            high_priority_gaps=high_priority,
-            recommended_action_plan=action_plan,
-            estimated_learning_hours=len(missing) * 6
-        )
-
-    def generate_resume_patch(self, resume_text: str, job: JobPosting) -> ResumePatch:
-        diffs = []
-        added_keywords = []
-
-        for skill in job.tech_stack:
-            if skill.lower() not in resume_text.lower():
-                added_keywords.append(skill)
-
-        domain = job.tech_domain.lower()
-
-        if "backend" in domain or "go" in [s.lower() for s in job.tech_stack]:
-            diffs.append({
-                "original": "Wrote backend APIs and managed database queries.",
-                "tailored": f"Engineered high-concurrency microservices in {job.tech_stack[0] if job.tech_stack else 'Go'}, optimizing low-latency data pipelines at {job.company}.",
-                "rationale": f"Highlights core backend technology ({job.tech_stack[0] if job.tech_stack else 'Go'}) requested in JD."
-            })
-
-        if "cloud" in domain or "devops" in domain or "kubernetes" in [s.lower() for s in job.tech_stack]:
-            diffs.append({
-                "original": "Managed cloud deployments and Docker scripts.",
-                "tailored": "Automated multi-region Kubernetes cluster deployment using Terraform and GitOps (ArgoCD), reducing deployment cycle time by 45%.",
-                "rationale": "Emphasizes infrastructure automation & GitOps patterns."
-            })
-
-        if "frontend" in domain or "react" in [s.lower() for s in job.tech_stack]:
-            diffs.append({
-                "original": "Built UI components in React.",
-                "tailored": "Architected performant React/Next.js design system components with server-side rendering (SSR), improving Core Web Vitals score to 95+.",
-                "rationale": "Showcases frontend performance metrics and SSR."
-            })
-
-        if not diffs:
-            diffs.append({
-                "original": "Worked on software development tasks and team deliverables.",
-                "tailored": f"Architected scalable solution utilizing {', '.join(job.tech_stack[:3])} to deliver high-availability software features at {job.company}.",
-                "rationale": "Injects critical tech stack keywords into resume."
-            })
-
-        ats_score = min(98.0, 72.0 + (len(added_keywords) * 3))
-
-        return ResumePatch(
-            target_job_id=job.id,
-            job_title=job.title,
-            company=job.company,
-            ats_compatibility_score=ats_score,
-            tailored_bullets=diffs,
-            added_keywords=added_keywords
-        )
-
-    def generate_interview_prep(self, job: JobPosting) -> InterviewPrepKit:
-        questions = []
-        domain = job.tech_domain.lower()
-
-        if "backend" in domain or "go" in [s.lower() for s in job.tech_stack]:
-            questions.append(InterviewQuestion(
-                question="How do you handle memory allocation and garbage collection tuning in high-concurrency Go / Java microservices?",
-                category="Backend & Systems",
-                difficulty="Hard",
-                ideal_answer_points=[
-                    "Explain stack vs heap allocation and escape analysis.",
-                    "Discuss sync.Pool for buffer reuse to minimize GC pauses under high QPS."
-                ],
-                company_context=f"Commonly evaluated at {job.company} ({job.city})."
-            ))
-
-        if "cloud" in domain or "devops" in domain:
-            questions.append(InterviewQuestion(
-                question="Explain zero-downtime blue/green deployment strategy in Kubernetes using ArgoCD / Helm.",
-                category="Cloud & DevOps",
-                difficulty="Intermediate",
-                ideal_answer_points=[
-                    "Use ingress controller routing rules to switch traffic between blue and green deployments.",
-                    "Automate health check probes and automated rollback on 5xx spike."
-                ]
-            ))
-
-        if "frontend" in domain:
-            questions.append(InterviewQuestion(
-                question="What is the difference between React Server Components (RSC) and traditional Client Side Rendering (CSR)?",
-                category="Frontend Engineering",
-                difficulty="Intermediate",
-                ideal_answer_points=[
-                    "RSC renders components on the server without sending JS bundle code to client.",
-                    "Reduces bundle size and improves initial page load (LCP)."
-                ]
-            ))
-
-        questions.append(InterviewQuestion(
-            question=f"Design a scalable system for {job.company} handling 50,000 requests/second using {', '.join(job.tech_stack[:3])}.",
-            category="System Design",
-            difficulty="Hard",
-            ideal_answer_points=[
-                "Implement API Gateway with rate limiting & OAuth token validation.",
-                "Partition microservices with message queues (Kafka) for asynchronous processing.",
-                "Use distributed caching (Redis) for database load reduction."
-            ]
-        ))
-
-        sys_design = {
-            "title": f"High-Scale System Architecture Challenge for {job.company} ({job.city})",
-            "domain": job.tech_domain,
-            "target_scale": "50K+ QPS",
-            "recommended_stack": f"{', '.join(job.tech_stack)}"
-        }
-
-        return InterviewPrepKit(
-            job_id=job.id,
-            job_title=job.title,
-            company=job.company,
-            city=job.city,
-            tech_domain=job.tech_domain,
-            technical_questions=questions,
-            system_design_challenge=sys_design,
-            prep_tips=[
-                f"Review {job.company}'s engineering blog and stack ({', '.join(job.tech_stack)}).",
-                "Prepare 2 system design diagrams detailing microservice boundaries & caching strategy.",
-                "Be ready to live-code algorithmic problem solving & concurrency patterns."
-            ]
-        )

tech_radar/tech_radar/agents/market_analyst.py

@@ -1,42 +0,0 @@
-from typing import Dict, Any, List
-from tech_radar.db.database import DatabaseManager
-from tech_radar.db.models import CityMarketInsights
-
-class MarketAnalystAgent:
-    """Generates universal market trend analytics across tech domains & cities."""
-
-    def __init__(self, db: DatabaseManager):
-        self.db = db
-
-    def generate_market_report(self, city: str = "All", domain: str = "All") -> CityMarketInsights:
-        data = self.db.get_market_analytics(city=city, domain=domain)
-        
-        return CityMarketInsights(
-            city=data["city"],
-            tech_domain=data["domain"],
-            total_active_jobs=data["total_jobs"],
-            avg_salary_lpa=data["avg_salary_lpa"],
-            salary_range=data["salary_range"],
-            top_demanded_frameworks=data["top_frameworks"],
-            top_hiring_hubs=data["top_hubs"],
-            top_employers=data["top_companies"],
-            growth_trend=f"🚀 Tech hiring for {domain} in {city} shows robust growth with competitive salary packages."
-        )
-
-    def generate_markdown_summary(self, city: str = "All", domain: str = "All") -> str:
-        insights = self.generate_market_report(city=city, domain=domain)
-        
-        md = f"# 📊 Tech Hiring Market Report — {insights.city.upper()} ({insights.tech_domain.upper()})\n\n"
-        md += f"**Total Active Roles Tracked**: {insights.total_active_jobs}\n"
-        md += f"**Average Salary Band**: {insights.avg_salary_lpa} LPA (Range: {insights.salary_range})\n"
-        md += f"**Market Sentiment**: {insights.growth_trend}\n\n"
-
-        md += "## 🔥 Top Demanded Tech Skills & Frameworks\n"
-        for item in insights.top_demanded_frameworks:
-            md += f"- **{item['skill']}**: Present in `{item['percentage']}%` of JDs ({item['count']} roles)\n"
-
-        md += "\n## 🏢 Leading Employers Hiring Tech Talent\n"
-        for company in insights.top_employers:
-            md += f"- {company}\n"
-
-        return md

tech_radar/tech_radar/agents/skill_extractor.py

@@ -1,70 +0,0 @@
-from typing import List, Dict, Any
-
-class SkillExtractorAgent:
-    """Categorizes tech skills into universal engineering taxonomy buckets."""
-
-    SKILL_TAXONOMY = {
-        "Backend & Microservices": ["Go", "Java", "Python", "C++", "Spring Boot", "FastAPI", "gRPC", "Node.js"],
-        "Frontend & UI": ["React", "Next.js", "TypeScript", "TailwindCSS", "Vue", "Zustand", "GraphQL", "HTML/CSS"],
-        "Cloud, DevOps & Infra": ["AWS", "Kubernetes", "Docker", "Terraform", "Helm", "ArgoCD", "CI/CD", "Prometheus"],
-        "Data & Databases": ["PostgreSQL", "Apache Kafka", "Apache Spark", "Snowflake", "Cassandra", "Redis", "Airflow", "SQL"],
-        "AI/ML & GenAI": ["FastMCP", "MCP", "LangGraph", "PyTorch", "vLLM", "CUDA", "Unsloth", "Qdrant", "DeepSpeed"],
-        "Mobile & Client": ["Kotlin", "Jetpack Compose", "Flutter", "Android SDK", "Swift", "iOS SDK"]
-    }
-
-    def categorize_skills(self, skills: List[str]) -> Dict[str, List[str]]:
-        result = {category: [] for category in self.SKILL_TAXONOMY}
-        result["Other Tech"] = []
-
-        for skill in skills:
-            matched = False
-            for category, taxonomy_skills in self.SKILL_TAXONOMY.items():
-                if any(skill.lower() == t.lower() for t in taxonomy_skills):
-                    result[category].append(skill)
-                    matched = True
-                    break
-            if not matched:
-                result["Other Tech"].append(skill)
-
-        return {k: v for k, v in result.items() if v}
-
-    def generate_learning_roadmap(self, missing_skills: List[str]) -> List[Dict[str, str]]:
-        roadmap = []
-        for skill in missing_skills:
-            s_lower = skill.lower()
-            if s_lower in ["go", "grpc"]:
-                roadmap.append({
-                    "skill": skill,
-                    "estimated_hours": "8 Hours",
-                    "micro_project": "Build a high-concurrency microservice in Go using gRPC, Protocol Buffers, and worker pools.",
-                    "resource": "https://go.dev/doc/tutorial/"
-                })
-            elif s_lower in ["kubernetes", "docker", "terraform"]:
-                roadmap.append({
-                    "skill": skill,
-                    "estimated_hours": "10 Hours",
-                    "micro_project": "Provision an EKS/GKE cluster with Terraform, configure Helm charts, and set up GitOps deployment.",
-                    "resource": "https://kubernetes.io/docs/tutorials/"
-                })
-            elif s_lower in ["react", "next.js", "typescript"]:
-                roadmap.append({
-                    "skill": skill,
-                    "estimated_hours": "6 Hours",
-                    "micro_project": "Create a modern Next.js 14 app featuring App Router, Server Components, and TypeScript state management.",
-                    "resource": "https://nextjs.org/docs"
-                })
-            elif s_lower in ["fastmcp", "mcp"]:
-                roadmap.append({
-                    "skill": skill,
-                    "estimated_hours": "6 Hours",
-                    "micro_project": "Build a custom Python FastMCP server exposing stdio/SSE tools for AI agents.",
-                    "resource": "https://modelcontextprotocol.io"
-                })
-            else:
-                roadmap.append({
-                    "skill": skill,
-                    "estimated_hours": "5 Hours",
-                    "micro_project": f"Build a practical micro-project integrating {skill} into a production pipeline.",
-                    "resource": "https://github.com/topics/software-engineering"
-                })
-        return roadmap

tech_radar/tech_radar/cli.py

@@ -1,108 +0,0 @@
-import click
-import sys
-import subprocess
-import os
-from rich.console import Console
-from rich.panel import Panel
-
-console = Console()
-
-@click.group()
-def cli():
-    """TechRadar MCP — Universal Tech Hiring Intelligence & MCP Ecosystem across India & Remote."""
-    pass
-
-@cli.command()
-@click.option("--live/--no-live", default=True, help="Fetch real-time live internet jobs from RemoteOK, Jobicy, WWR")
-def seed(live):
-    """Seed SQLite database & Vector Engine with curated + live internet job postings."""
-    console.print(f"[bold green]🌱 Seeding TechRadar Database (Live Scraping: {live})...[/bold green]")
-    from tech_radar.scrapers.seeder import seed_database
-    seed_database(fetch_live=live)
-
-@cli.command()
-def scrape_live():
-    """Trigger real-time live internet job scraping pipeline."""
-    console.print("[bold cyan]🌐 Executing Live Internet Job Scraper Pipeline...[/bold cyan]")
-    from tech_radar.scrapers.live_scraper import LiveInternetScraper
-    from tech_radar.db.database import DatabaseManager
-    from tech_radar.db.vector_store import SemanticVectorStore
-
-    scraper = LiveInternetScraper()
-    live_jobs = scraper.fetch_all_live_jobs()
-    db = DatabaseManager()
-    for job in live_jobs:
-        db.save_job_posting(job)
-
-    vector_store = SemanticVectorStore()
-    all_jobs = db.get_all_jobs()
-    vector_store.index_jobs(all_jobs)
-    console.print(f"[bold green]✅ Ingested {len(live_jobs)} live jobs! Total jobs in database: {len(all_jobs)}[/bold green]")
-
-@cli.command()
-@click.option("--transport", default="stdio", type=click.Choice(["stdio", "sse"]), help="MCP transport protocol")
-def serve(transport):
-    """Start the FastMCP Protocol Server for Claude Desktop or Cursor IDE."""
-    console.print(Panel.fit(
-        f"[bold magenta]⚡ Starting TechRadar FastMCP Server ({transport} mode)...[/bold magenta]\n"
-        "[dim]Exposing tools: search_tech_jobs, analyze_skill_gap, generate_tailored_resume_patch, get_market_insights, generate_interview_prep_kit[/dim]",
-        title="TechRadar MCP"
-    ))
-    from tech_radar.mcp.server import mcp
-    if transport == "stdio":
-        mcp.run(transport="stdio")
-    else:
-        mcp.run(transport="sse")
-
-@cli.command()
-@click.option("--port", default=8000, help="Port to run 3D Web App frontend on")
-def web(port):
-    """Launch the 3D Cyber-Glassmorphic Web App frontend."""
-    console.print(f"[bold cyan]🌐 Launching 3D Cyber-Glassmorphic TechRadar Web App on http://localhost:{port}...[/bold cyan]")
-    import uvicorn
-    uvicorn.run("tech_radar.ui.static_server:app", host="0.0.0.0", port=port, reload=True)
-
-@cli.command()
-@click.option("--port", default=8501, help="Port to run Streamlit dashboard on")
-def ui(port):
-    """Launch the Interactive Streamlit Dashboard."""
-    console.print(f"[bold cyan]🚀 Launching TechRadar Streamlit Dashboard on http://localhost:{port}...[/bold cyan]")
-    app_path = os.path.join(os.path.dirname(__file__), "ui", "app.py")
-    subprocess.run([sys.executable, "-m", "streamlit", "run", app_path, "--server.port", str(port)])
-
-@cli.command()
-def test_mcp():
-    """Run automated end-to-end verification of all FastMCP tools."""
-    console.print("[bold yellow]🧪 Running Automated FastMCP Server Verification...[/bold yellow]")
-    from tech_radar.mcp.tools import (
-        tool_search_tech_jobs,
-        tool_analyze_skill_gap,
-        tool_generate_resume_patch,
-        tool_get_market_insights,
-        tool_generate_interview_prep_kit
-    )
-
-    console.print("\n1. Testing 'search_tech_jobs' (Backend in Bengaluru)...")
-    res1 = tool_search_tech_jobs(domain="Backend Engineering", city="Bengaluru", query="Go")
-    console.print(f"   Success! Retreived response size: {len(res1)} bytes")
-
-    console.print("\n2. Testing 'get_market_insights' (Cloud in Hyderabad)...")
-    res2 = tool_get_market_insights(domain="Cloud & DevOps", city="Hyderabad")
-    console.print(f"   Success! Retreived response size: {len(res2)} bytes")
-
-    console.print("\n3. Testing 'analyze_skill_gap' (BLR-BACKEND-101)...")
-    res3 = tool_analyze_skill_gap(resume_text="Go & Docker developer", target_job_id="BLR-BACKEND-101")
-    console.print(f"   Success! Retreived response size: {len(res3)} bytes")
-
-    console.print("\n4. Testing 'generate_tailored_resume_patch' (PUNE-FULLSTACK-202)...")
-    res4 = tool_generate_resume_patch(resume_text="Python React dev", target_job_id="PUNE-FULLSTACK-202")
-    console.print(f"   Success! Retreived response size: {len(res4)} bytes")
-
-    console.print("\n5. Testing 'generate_interview_prep_kit' (BLR-FRONTEND-201)...")
-    res5 = tool_generate_interview_prep_kit(target_job_id="BLR-FRONTEND-201")
-    console.print(f"   Success! Retreived response size: {len(res5)} bytes")
-
-    console.print("\n[bold green]✅ All 5 FastMCP Tools verified successfully![/bold green]")
-
-if __name__ == "__main__":
-    cli()

tech_radar/tech_radar/db/database.py

@@ -1,218 +0,0 @@
-import sqlite3
-import json
-import os
-from typing import List, Optional, Dict, Any
-from tech_radar.db.models import JobPosting
-
-class DatabaseManager:
-    """Thread-safe SQLite database manager for TechRadar-MCP across all domains & cities."""
-
-    def __init__(self, db_path: str = "tech_radar.db"):
-        self.db_path = db_path
-        self._init_db()
-
-    def _get_connection(self) -> sqlite3.Connection:
-        conn = sqlite3.connect(self.db_path)
-        conn.row_factory = sqlite3.Row
-        return conn
-
-    def _init_db(self):
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                CREATE TABLE IF NOT EXISTS job_postings (
-                    id TEXT PRIMARY KEY,
-                    title TEXT NOT NULL,
-                    company TEXT NOT NULL,
-                    tech_domain TEXT NOT NULL,
-                    city TEXT NOT NULL,
-                    area TEXT NOT NULL,
-                    salary_min_lpa REAL NOT NULL,
-                    salary_max_lpa REAL NOT NULL,
-                    experience_min_years INTEGER NOT NULL,
-                    experience_max_years INTEGER NOT NULL,
-                    tech_stack TEXT NOT NULL, -- JSON List
-                    requirements TEXT NOT NULL,
-                    work_mode TEXT NOT NULL,
-                    company_tier TEXT NOT NULL,
-                    posted_date TEXT NOT NULL,
-                    url TEXT
-                )
-            """)
-            conn.commit()
-
-    def save_job_posting(self, job: JobPosting) -> bool:
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("""
-                INSERT OR REPLACE INTO job_postings (
-                    id, title, company, tech_domain, city, area, salary_min_lpa, salary_max_lpa,
-                    experience_min_years, experience_max_years, tech_stack, requirements,
-                    work_mode, company_tier, posted_date, url
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            """, (
-                job.id, job.title, job.company, job.tech_domain, job.city, job.area,
-                job.salary_min_lpa, job.salary_max_lpa,
-                job.experience_min_years, job.experience_max_years,
-                json.dumps(job.tech_stack), job.requirements,
-                job.work_mode, job.company_tier, job.posted_date, job.url
-            ))
-            conn.commit()
-            return True
-
-    def get_job_by_id(self, job_id: str) -> Optional[JobPosting]:
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
-            cursor.execute("SELECT * FROM job_postings WHERE id = ?", (job_id,))
-            row = cursor.fetchone()
-            if not row:
-                return None
-            return self._row_to_job(row)
-
-    def search_jobs(
-        self,
-        domain: Optional[str] = None,
-        city: Optional[str] = None,
-        query: Optional[str] = None,
-        experience_level: Optional[int] = None,
-        min_salary_lpa: Optional[float] = None,
-        tech_stack_filter: Optional[List[str]] = None,
-        limit: int = 100
-    ) -> List[JobPosting]:
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
-            sql = "SELECT * FROM job_postings WHERE 1=1"
-            params = []
-
-            if domain and domain.lower() != "all":
-                sql += " AND LOWER(tech_domain) = LOWER(?)"
-                params.append(domain)
-
-            if city and city.lower() != "all":
-                sql += " AND LOWER(city) = LOWER(?)"
-                params.append(city)
-
-            if experience_level is not None:
-                sql += " AND experience_min_years <= ? AND experience_max_years >= ?"
-                params.extend([experience_level, experience_level])
-
-            if min_salary_lpa is not None:
-                sql += " AND salary_max_lpa >= ?"
-                params.append(min_salary_lpa)
-
-            if query:
-                sql += " AND (LOWER(title) LIKE LOWER(?) OR LOWER(company) LIKE LOWER(?) OR LOWER(requirements) LIKE LOWER(?) OR LOWER(area) LIKE LOWER(?))"
-                q = f"%{query}%"
-                params.extend([q, q, q, q])
-
-            sql += " ORDER BY salary_max_lpa DESC LIMIT ?"
-            params.append(limit)
-
-            cursor.execute(sql, params)
-            rows = cursor.fetchall()
-            jobs = [self._row_to_job(r) for r in rows]
-
-            if tech_stack_filter:
-                filter_set = {s.lower() for s in tech_stack_filter}
-                jobs = [
-                    j for j in jobs
-                    if any(ts.lower() in filter_set for ts in j.tech_stack)
-                ]
-
-            return jobs
-
-    def get_all_jobs(self) -> List[JobPosting]:
-        return self.search_jobs(limit=500)
-
-    def get_market_analytics(self, city: str = "All", domain: str = "All") -> Dict[str, Any]:
-        with self._get_connection() as conn:
-            cursor = conn.cursor()
-            sql = "SELECT COUNT(*), AVG((salary_min_lpa + salary_max_lpa) / 2.0), MIN(salary_min_lpa), MAX(salary_max_lpa) FROM job_postings WHERE 1=1"
-            params = []
-
-            if city and city.lower() != "all":
-                sql += " AND LOWER(city) = LOWER(?)"
-                params.append(city)
-
-            if domain and domain.lower() != "all":
-                sql += " AND LOWER(tech_domain) = LOWER(?)"
-                params.append(domain)
-
-            cursor.execute(sql, params)
-            count, avg_sal, min_sal, max_sal = cursor.fetchone()
-
-            if not count or count == 0:
-                return {
-                    "city": city,
-                    "domain": domain,
-                    "total_jobs": 0,
-                    "avg_salary_lpa": 0,
-                    "salary_range": "N/A",
-                    "top_frameworks": [],
-                    "top_hubs": [],
-                    "top_companies": []
-                }
-
-            sql_details = "SELECT tech_stack, area, company FROM job_postings WHERE 1=1"
-            params_details = []
-            if city and city.lower() != "all":
-                sql_details += " AND LOWER(city) = LOWER(?)"
-                params_details.append(city)
-            if domain and domain.lower() != "all":
-                sql_details += " AND LOWER(tech_domain) = LOWER(?)"
-                params_details.append(domain)
-
-            cursor.execute(sql_details, params_details)
-            rows = cursor.fetchall()
-
-            skill_counts = {}
-            hub_counts = {}
-            company_set = set()
-
-            for r in rows:
-                stacks = json.loads(r["tech_stack"])
-                for s in stacks:
-                    skill_counts[s] = skill_counts.get(s, 0) + 1
-                area = r["area"]
-                hub_counts[area] = hub_counts.get(area, 0) + 1
-                company_set.add(r["company"])
-
-            sorted_skills = [
-                {"skill": k, "count": v, "percentage": round((v / count) * 100, 1)}
-                for k, v in sorted(skill_counts.items(), key=lambda x: x[1], reverse=True)[:10]
-            ]
-            sorted_hubs = [
-                {"hub": k, "count": v}
-                for k, v in sorted(hub_counts.items(), key=lambda x: x[1], reverse=True)[:5]
-            ]
-
-            return {
-                "city": city,
-                "domain": domain,
-                "total_jobs": count,
-                "avg_salary_lpa": round(avg_sal or 0, 1),
-                "salary_range": f"₹{int(min_sal or 0)}L - ₹{int(max_sal or 0)}L PA",
-                "top_frameworks": sorted_skills,
-                "top_hubs": sorted_hubs,
-                "top_companies": list(company_set)[:10]
-            }
-
-    def _row_to_job(self, row: sqlite3.Row) -> JobPosting:
-        return JobPosting(
-            id=row["id"],
-            title=row["title"],
-            company=row["company"],
-            tech_domain=row["tech_domain"],
-            city=row["city"],
-            area=row["area"],
-            salary_min_lpa=row["salary_min_lpa"],
-            salary_max_lpa=row["salary_max_lpa"],
-            experience_min_years=row["experience_min_years"],
-            experience_max_years=row["experience_max_years"],
-            tech_stack=json.loads(row["tech_stack"]),
-            requirements=row["requirements"],
-            work_mode=row["work_mode"],
-            company_tier=row["company_tier"],
-            posted_date=row["posted_date"],
-            url=row["url"]
-        )

tech_radar/tech_radar/db/models.py

@@ -1,74 +0,0 @@
-from typing import List, Dict, Optional, Any
-from pydantic import BaseModel, Field
-from datetime import datetime
-
-class JobPosting(BaseModel):
-    id: str = Field(..., description="Unique job identifier, e.g. JOB-BLR-101")
-    title: str = Field(..., description="Job title, e.g., Senior Backend Engineer (Go/Distributed Systems)")
-    company: str = Field(..., description="Company name")
-    tech_domain: str = Field(default="Backend Engineering", description="Domain: Backend, Frontend, Full Stack, DevOps/Cloud, Data Engineering, AI/ML & GenAI, Mobile, Cybersecurity")
-    city: str = Field(default="Bengaluru", description="City location: Bengaluru, Pune, Hyderabad, Gurgaon, Mumbai, Chennai, Remote")
-    area: str = Field(default="Indiranagar", description="Locality or Tech Park, e.g. Outer Ring Road, Hinjawadi, HITEC City, Cyber City")
-    salary_min_lpa: float = Field(..., description="Minimum salary in Lakhs Per Annum (LPA)")
-    salary_max_lpa: float = Field(..., description="Maximum salary in Lakhs Per Annum (LPA)")
-    experience_min_years: int = Field(..., description="Minimum experience required in years")
-    experience_max_years: int = Field(..., description="Maximum experience requested in years")
-    tech_stack: List[str] = Field(default_factory=list, description="Extracted tech stack, e.g., ['Go', 'Kubernetes', 'gRPC', 'PostgreSQL', 'Redis']")
-    requirements: str = Field(..., description="Full text job description and responsibilities")
-    work_mode: str = Field(default="Hybrid", description="Hybrid, On-site, or Remote")
-    company_tier: str = Field(default="Product Unicorn / Enterprise", description="Company tier")
-    posted_date: str = Field(default_factory=lambda: datetime.now().strftime("%Y-%m-%d"))
-    url: Optional[str] = Field(default="https://techradar.ai/jobs", description="Job posting URL")
-    semantic_score: Optional[float] = Field(default=None, description="Relevance score from semantic vector search")
-
-class SkillGapReport(BaseModel):
-    target_job_id: str
-    job_title: str
-    company: str
-    city: str
-    tech_domain: str
-    match_percentage: float = Field(..., description="Overall candidate match percentage (0-100%)")
-    matched_skills: List[str] = Field(default_factory=list, description="Skills present in candidate profile & JD")
-    missing_skills: List[str] = Field(default_factory=list, description="Critical skills in JD missing from candidate profile")
-    high_priority_gaps: List[str] = Field(default_factory=list, description="Top deal-breaker missing skills for this role")
-    recommended_action_plan: List[Dict[str, str]] = Field(default_factory=list, description="Actionable micro-projects to bridge gaps")
-    estimated_learning_hours: int = Field(default=20, description="Estimated effort to reach 90%+ match")
-
-class ResumePatch(BaseModel):
-    target_job_id: str
-    job_title: str
-    company: str
-    ats_compatibility_score: float = Field(..., description="Score out of 100 for ATS parsing")
-    tailored_bullets: List[Dict[str, str]] = Field(
-        ...,
-        description="List of dicts with 'original', 'tailored', and 'rationale'"
-    )
-    added_keywords: List[str] = Field(default_factory=list, description="Keywords injected for ATS optimization")
-
-class CityMarketInsights(BaseModel):
-    city: str
-    tech_domain: str
-    total_active_jobs: int
-    avg_salary_lpa: float
-    salary_range: str
-    top_demanded_frameworks: List[Dict[str, Any]]
-    top_hiring_hubs: List[Dict[str, Any]]
-    top_employers: List[str]
-    growth_trend: str
-
-class InterviewQuestion(BaseModel):
-    question: str
-    category: str
-    difficulty: str
-    ideal_answer_points: List[str]
-    company_context: Optional[str] = None
-
-class InterviewPrepKit(BaseModel):
-    job_id: str
-    job_title: str
-    company: str
-    city: str
-    tech_domain: str
-    technical_questions: List[InterviewQuestion]
-    system_design_challenge: Dict[str, Any]
-    prep_tips: List[str]

tech_radar/tech_radar/db/vector_store.py

@@ -1,119 +0,0 @@
-import math
-import re
-from typing import List, Tuple, Dict, Any
-from tech_radar.db.models import JobPosting
-
-class SemanticVectorStore:
-    """
-    Lightweight, high-performance Vector & Semantic Search Engine for TechRadar-MCP across all software domains.
-    """
-
-    def __init__(self):
-        self.jobs: List[JobPosting] = []
-        self.doc_vectors: List[Dict[str, float]] = []
-        self.idf: Dict[str, float] = {}
-
-    def _tokenize(self, text: str) -> List[str]:
-        words = re.findall(r'\b[a-zA-Z0-9+#\.-]+\b', text.lower())
-        return [w for w in words if len(w) > 1]
-
-    def index_jobs(self, jobs: List[JobPosting]):
-        self.jobs = jobs
-        self.doc_vectors = []
-        doc_count = len(jobs)
-        doc_freq = {}
-
-        raw_docs = []
-        for job in jobs:
-            text = f"{job.title} {job.company} {job.tech_domain} {job.city} {job.area} {' '.join(job.tech_stack)} {job.requirements}"
-            tokens = self._tokenize(text)
-            raw_docs.append(tokens)
-            unique_tokens = set(tokens)
-            for token in unique_tokens:
-                doc_freq[token] = doc_freq.get(token, 0) + 1
-
-        self.idf = {
-            token: math.log((doc_count + 1) / (freq + 1)) + 1.0
-            for token, freq in doc_freq.items()
-        }
-
-        for tokens in raw_docs:
-            tf = {}
-            for t in tokens:
-                tf[t] = tf.get(t, 0) + 1
-            length = len(tokens) or 1
-            vec = {
-                term: (freq / length) * self.idf.get(term, 1.0)
-                for term, freq in tf.items()
-            }
-            self.doc_vectors.append(vec)
-
-    def _cosine_similarity(self, vec1: Dict[str, float], vec2: Dict[str, float]) -> float:
-        intersection = set(vec1.keys()) & set(vec2.keys())
-        numerator = sum(vec1[x] * vec2[x] for x in intersection)
-        
-        sum1 = sum(val ** 2 for val in vec1.values())
-        sum2 = sum(val ** 2 for val in vec2.values())
-        denominator = math.sqrt(sum1) * math.sqrt(sum2)
-        
-        if not denominator:
-            return 0.0
-        return float(numerator / denominator)
-
-    def search_semantic(
-        self,
-        query: str,
-        domain: str = None,
-        city: str = None,
-        top_k: int = 15
-    ) -> List[Tuple[JobPosting, float]]:
-        if not self.doc_vectors or not self.jobs:
-            return []
-
-        q_tokens = self._tokenize(query)
-        tf = {}
-        for t in q_tokens:
-            tf[t] = tf.get(t, 0) + 1
-        q_length = len(q_tokens) or 1
-        q_vec = {
-            term: (freq / q_length) * self.idf.get(term, 1.0)
-            for term, freq in tf.items()
-        }
-
-        results = []
-        for idx, job in enumerate(self.jobs):
-            if city and city.lower() != "all" and job.city.lower() != city.lower():
-                continue
-            if domain and domain.lower() != "all" and job.tech_domain.lower() != domain.lower():
-                continue
-
-            sim = self._cosine_similarity(q_vec, self.doc_vectors[idx])
-            
-            tech_match_bonus = sum(
-                0.15 for t in q_tokens
-                if any(t.lower() == stack.lower() for stack in job.tech_stack)
-            )
-            final_score = round(min(1.0, sim + tech_match_bonus), 3)
-            
-            if final_score > 0.01:
-                results.append((job, final_score))
-
-        results.sort(key=lambda x: x[1], reverse=True)
-        return results[:top_k]
-
-    def match_resume_to_jd(self, resume_text: str, job: JobPosting) -> float:
-        r_tokens = self._tokenize(resume_text)
-        jd_text = f"{job.title} {job.tech_domain} {' '.join(job.tech_stack)} {job.requirements}"
-        jd_tokens = self._tokenize(jd_text)
-
-        r_set = set(r_tokens)
-        jd_set = set(jd_tokens)
-
-        tech_matches = [t for t in job.tech_stack if any(t.lower() == r.lower() for r in r_set)]
-        tech_ratio = len(tech_matches) / (len(job.tech_stack) or 1)
-
-        common_vocab = r_set & jd_set
-        vocab_ratio = len(common_vocab) / (len(jd_set) or 1)
-
-        overall_score = (tech_ratio * 0.6) + (vocab_ratio * 0.4)
-        return round(min(99.0, overall_score * 100.0), 1)

tech_radar/tech_radar/mcp/prompts.py

@@ -1,15 +0,0 @@
-def prompt_tech_career_coach(candidate_target_city: str = "All", domain_interest: str = "Software Engineering", resume_summary: str = "") -> str:
-    """Prompt template for AI assistant acting as a Universal Tech Career Coach."""
-    return f"""You are the TechRadar Universal Career Coach specialized in Software & AI hiring across India & Remote.
-Target City / Hub: {candidate_target_city}
-Domain Interest: {domain_interest}
-Candidate Summary: {resume_summary or 'Software Engineer'}
-
-Instructions:
-1. Use the 'search_tech_jobs' MCP tool to find matching active roles across companies in {candidate_target_city}.
-2. Use 'analyze_skill_gap' to identify missing domain skills and frameworks.
-3. Use 'generate_tailored_resume_patch' to suggest bullet point diffs for ATS optimization.
-4. Use 'generate_interview_prep_kit' to prepare technical interview questions & system design challenges.
-
-Provide clear, encouraging, and highly technical actionable advice.
-"""

tech_radar/tech_radar/mcp/resources.py

@@ -1,13 +0,0 @@
-from tech_radar.mcp.tools import get_db_and_vector_store
-import json
-
-def resource_india_tech_market_report() -> str:
-    """Return universal India Tech Hiring Market Intelligence Report in Markdown."""
-    _, _, _, analyst = get_db_and_vector_store()
-    return analyst.generate_markdown_summary(city="All", domain="All")
-
-def resource_latest_jobs_json() -> str:
-    """Return JSON snapshot of active tech jobs across India & Remote."""
-    db, _, _, _ = get_db_and_vector_store()
-    jobs = [j.dict() for j in db.get_all_jobs()[:20]]
-    return json.dumps(jobs, indent=2)

tech_radar/tech_radar/mcp/server.py

@@ -1,106 +0,0 @@
-import sys
-import os
-from typing import Optional, List
-from fastmcp import FastMCP
-
-from tech_radar.mcp.tools import (
-    tool_search_tech_jobs,
-    tool_analyze_skill_gap,
-    tool_generate_resume_patch,
-    tool_get_market_insights,
-    tool_generate_interview_prep_kit
-)
-from tech_radar.mcp.resources import (
-    resource_india_tech_market_report,
-    resource_latest_jobs_json
-)
-from tech_radar.mcp.prompts import prompt_tech_career_coach
-
-# FastMCP Server Instance
-mcp = FastMCP(
-    name="Tech-Radar-India",
-    instructions=(
-        "TechRadar is a Model Context Protocol (MCP) server providing universal job market intelligence, "
-        "semantic search, candidate skill gap analysis, ATS resume patching, and interview prep kits for "
-        "Software Engineering, Cloud, Data, and AI/ML roles across Indian tech hubs (Bengaluru, Pune, Hyderabad, Gurgaon, Remote)."
-    )
-)
-
-@mcp.tool(
-    name="search_tech_jobs",
-    description="Search active software & tech job openings across domains (Backend, Frontend, Full Stack, DevOps, Data, AI/ML, Mobile) and cities."
-)
-def search_tech_jobs(
-    domain: str = "All",
-    city: str = "All",
-    query: Optional[str] = None,
-    experience_level: Optional[int] = None,
-    min_salary_lpa: Optional[float] = None,
-    limit: int = 15
-) -> str:
-    return tool_search_tech_jobs(
-        domain=domain,
-        city=city,
-        query=query,
-        experience_level=experience_level,
-        min_salary_lpa=min_salary_lpa,
-        limit=limit
-    )
-
-@mcp.tool(
-    name="analyze_skill_gap",
-    description="Analyze candidate resume against target tech Job ID. Returns match score, missing skills, and micro-learning plan."
-)
-def analyze_skill_gap(
-    resume_text: str,
-    target_job_id: str
-) -> str:
-    return tool_analyze_skill_gap(resume_text=resume_text, target_job_id=target_job_id)
-
-@mcp.tool(
-    name="generate_tailored_resume_patch",
-    description="Generate customized ATS bullet point diffs and keyword injections for any target software role."
-)
-def generate_tailored_resume_patch(
-    resume_text: str,
-    target_job_id: str
-) -> str:
-    return tool_generate_resume_patch(resume_text=resume_text, target_job_id=target_job_id)
-
-@mcp.tool(
-    name="get_market_insights",
-    description="Get real-time hiring trends, salary distribution, tech hub breakdowns, and top employers for any domain and city."
-)
-def get_market_insights(
-    domain: str = "All",
-    city: str = "All"
-) -> str:
-    return tool_get_market_insights(domain=domain, city=city)
-
-@mcp.tool(
-    name="generate_interview_prep_kit",
-    description="Generate domain-specific technical interview questions, system design challenge, and answer key for a target job ID."
-)
-def generate_interview_prep_kit(
-    target_job_id: str
-) -> str:
-    return tool_generate_interview_prep_kit(target_job_id=target_job_id)
-
-@mcp.resource(path="market://india-tech-report")
-def india_tech_market_report() -> str:
-    return resource_india_tech_market_report()
-
-@mcp.resource(path="jobs://latest-tech-jobs")
-def latest_jobs_json() -> str:
-    return resource_latest_jobs_json()
-
-@mcp.prompt(name="tech_career_coach")
-def tech_career_coach(candidate_target_city: str = "All", domain_interest: str = "Software Engineering", resume_summary: str = "") -> str:
-    return prompt_tech_career_coach(candidate_target_city=candidate_target_city, domain_interest=domain_interest, resume_summary=resume_summary)
-
-def run():
-    """Run FastMCP server over stdio."""
-    mcp.run(transport="stdio")
-
-if __name__ == "__main__":
-    run()

tech_radar/tech_radar/mcp/tools.py

@@ -1,116 +0,0 @@
-import json
-from typing import List, Optional, Dict, Any
-from tech_radar.db.database import DatabaseManager
-from tech_radar.db.vector_store import SemanticVectorStore
-from tech_radar.agents.evaluator_agent import EvaluatorAgent
-from tech_radar.agents.market_analyst import MarketAnalystAgent
-from tech_radar.scrapers.seeder import seed_database
-
-_db: Optional[DatabaseManager] = None
-_vector_store: Optional[SemanticVectorStore] = None
-_evaluator: Optional[EvaluatorAgent] = None
-_market_analyst: Optional[MarketAnalystAgent] = None
-
-def get_db_and_vector_store():
-    global _db, _vector_store, _evaluator, _market_analyst
-    if _db is None or _vector_store is None:
-        _db, _vector_store = seed_database()
-        _evaluator = EvaluatorAgent()
-        _market_analyst = MarketAnalystAgent(_db)
-    return _db, _vector_store, _evaluator, _market_analyst
-
-def tool_search_tech_jobs(
-    domain: str = "All",
-    city: str = "All",
-    query: Optional[str] = None,
-    experience_level: Optional[int] = None,
-    min_salary_lpa: Optional[float] = None,
-    tech_stack: Optional[List[str]] = None,
-    limit: int = 15
-) -> str:
-    """
-    Search tech job opportunities across domains (Backend, Frontend, Full Stack, DevOps, Data, AI/ML, Mobile)
-    and cities (Bengaluru, Pune, Hyderabad, Gurgaon, Mumbai, Remote).
-    """
-    db, vector_store, _, _ = get_db_and_vector_store()
-
-    if query:
-        semantic_results = vector_store.search_semantic(query=query, domain=domain, city=city, top_k=limit)
-        jobs = []
-        for j, score in semantic_results:
-            j.semantic_score = score
-            jobs.append(j.dict())
-    else:
-        filtered = db.search_jobs(
-            domain=domain,
-            city=city,
-            query=query,
-            experience_level=experience_level,
-            min_salary_lpa=min_salary_lpa,
-            tech_stack_filter=tech_stack,
-            limit=limit
-        )
-        jobs = [j.dict() for j in filtered]
-
-    return json.dumps({
-        "count": len(jobs),
-        "domain": domain,
-        "city": city,
-        "jobs": jobs
-    }, indent=2)
-
-def tool_analyze_skill_gap(
-    resume_text: str,
-    target_job_id: str
-) -> str:
-    """
-    Perform candidate skill gap evaluation against any target tech Job ID.
-    Returns match percentage, missing skills, and micro-learning action plan.
-    """
-    db, _, evaluator, _ = get_db_and_vector_store()
-    job = db.get_job_by_id(target_job_id)
-    if not job:
-        return json.dumps({"error": f"Job ID '{target_job_id}' not found in database."})
-
-    report = evaluator.evaluate_skill_gap(resume_text=resume_text, candidate_skills=[], job=job)
-    return json.dumps(report.dict(), indent=2)
-
-def tool_generate_resume_patch(
-    resume_text: str,
-    target_job_id: str
-) -> str:
-    """
-    Generate tailored ATS bullet point diffs and keyword recommendations for any target software role.
-    """
-    db, _, evaluator, _ = get_db_and_vector_store()
-    job = db.get_job_by_id(target_job_id)
-    if not job:
-        return json.dumps({"error": f"Job ID '{target_job_id}' not found in database."})
-
-    patch = evaluator.generate_resume_patch(resume_text=resume_text, job=job)
-    return json.dumps(patch.dict(), indent=2)
-
-def tool_get_market_insights(
-    domain: str = "All",
-    city: str = "All"
-) -> str:
-    """
-    Get real-time hiring trends, salary distribution, and top employers for any tech domain and city.
-    """
-    _, _, _, analyst = get_db_and_vector_store()
-    insights = analyst.generate_market_report(city=city, domain=domain)
-    return json.dumps(insights.dict(), indent=2)
-
-def tool_generate_interview_prep_kit(
-    target_job_id: str
-) -> str:
-    """
-    Generate domain-specific technical interview questions, system design challenge, and answer key for a target job ID.
-    """
-    db, _, evaluator, _ = get_db_and_vector_store()
-    job = db.get_job_by_id(target_job_id)
-    if not job:
-        return json.dumps({"error": f"Job ID '{target_job_id}' not found in database."})
-
-    prep_kit = evaluator.generate_interview_prep(job=job)
-    return json.dumps(prep_kit.dict(), indent=2)

tech_radar/tech_radar/scrapers/live_scraper.py

@@ -1,272 +0,0 @@
-import requests
-from bs4 import BeautifulSoup
-import re
-import json
-import warnings
-from typing import List, Dict, Any, Optional
-from datetime import datetime
-
-from tech_radar.db.models import JobPosting
-
-warnings.filterwarnings("ignore")
-
-class LiveInternetScraper:
-    """
-    Autonomous Live Internet Job Scraper Engine for TechRadar-MCP.
-    Aggregates live, real-time tech postings from RemoteOK, Jobicy, and WeWorkRemotely feeds.
-    """
-
-    def __init__(self):
-        self.headers = {
-            "User-Agent": (
-                "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
-                "AppleWebKit/537.36 (KHTML, like Gecko) "
-                "Chrome/120.0.0.0 Safari/537.36"
-            )
-        }
-
-    def fetch_all_live_jobs(self) -> List[JobPosting]:
-        """Fetch real-time live jobs from all active internet APIs & feeds."""
-        live_jobs: List[JobPosting] = []
-
-        # 1. Fetch RemoteOK Live API
-        print("[LiveScraper] Ingesting live jobs from RemoteOK API...")
-        try:
-            remote_ok_jobs = self._scrape_remoteok()
-            live_jobs.extend(remote_ok_jobs)
-            print(f" -> Fetched {len(remote_ok_jobs)} live jobs from RemoteOK.")
-        except Exception as e:
-            print(f"[LiveScraper] RemoteOK error: {e}")
-
-        # 2. Fetch Jobicy Live API
-        print("[LiveScraper] Ingesting live jobs from Jobicy API...")
-        try:
-            jobicy_jobs = self._scrape_jobicy()
-            live_jobs.extend(jobicy_jobs)
-            print(f" -> Fetched {len(jobicy_jobs)} live jobs from Jobicy.")
-        except Exception as e:
-            print(f"[LiveScraper] Jobicy error: {e}")
-
-        # 3. Fetch WeWorkRemotely RSS
-        print("[LiveScraper] Ingesting live jobs from WeWorkRemotely RSS...")
-        try:
-            wwr_jobs = self._scrape_weworkremotely()
-            live_jobs.extend(wwr_jobs)
-            print(f" -> Fetched {len(wwr_jobs)} live jobs from WeWorkRemotely.")
-        except Exception as e:
-            print(f"[LiveScraper] WeWorkRemotely error: {e}")
-
-        print(f"✨ Total Live Internet Jobs Ingested: {len(live_jobs)}")
-        return live_jobs
-
-    def _scrape_remoteok(self) -> List[JobPosting]:
-        url = "https://remoteok.com/api"
-        resp = requests.get(url, headers=self.headers, timeout=12)
-        if resp.status_code != 200:
-            return []
-
-        raw_data = resp.json()
-        jobs = []
-
-        # RemoteOK first item is metadata
-        items = raw_data[1:] if isinstance(raw_data, list) and len(raw_data) > 1 else []
-
-        for item in items:
-            if not isinstance(item, dict) or "position" not in item:
-                continue
-
-            title = item.get("position", "Software Engineer")
-            company = item.get("company", "Tech Company")
-            tags = item.get("tags", [])
-            location = item.get("location", "Remote")
-            desc = item.get("description", title)
-            job_url = item.get("url", "https://remoteok.com")
-            raw_id = item.get("id", str(abs(hash(title + company)) % 100000))
-
-            domain = self.detect_domain(title, tags)
-            city = self.detect_city(location)
-            salary_min, salary_max = self.extract_salary_lpa(item.get("salary_min"), item.get("salary_max"), desc)
-
-            jobs.append(JobPosting(
-                id=f"LIVE-ROK-{raw_id}",
-                title=title[:70],
-                company=company[:50],
-                tech_domain=domain,
-                city=city,
-                area=location[:30] if location else "Remote Hub",
-                salary_min_lpa=salary_min,
-                salary_max_lpa=salary_max,
-                experience_min_years=2,
-                experience_max_years=7,
-                tech_stack=tags[:8] if tags else ["Python", "Docker", "API"],
-                requirements=self.clean_html(desc)[:1000],
-                work_mode="Remote" if "remote" in location.lower() or not location else "Hybrid",
-                company_tier="Global Remote / Tech Enterprise",
-                posted_date=datetime.now().strftime("%Y-%m-%d"),
-                url=job_url
-            ))
-
-        return jobs
-
-    def _scrape_jobicy(self) -> List[JobPosting]:
-        url = "https://jobicy.com/api/v2/remote-jobs"
-        resp = requests.get(url, headers=self.headers, timeout=12)
-        if resp.status_code != 200:
-            return []
-
-        raw_data = resp.json().get("jobs", [])
-        jobs = []
-
-        for item in raw_data:
-            title = item.get("jobTitle", "Software Engineer")
-            company = item.get("companyName", "Tech Firm")
-            geo = item.get("jobGeo", "Remote")
-            desc = item.get("jobDescription", title)
-            job_url = item.get("url", "https://jobicy.com")
-            raw_id = item.get("id", str(abs(hash(title + company)) % 100000))
-
-            domain = self.detect_domain(title, [item.get("jobCategory", "")])
-            city = self.detect_city(geo)
-            salary_min, salary_max = self.extract_salary_lpa(None, None, desc)
-
-            jobs.append(JobPosting(
-                id=f"LIVE-JBC-{raw_id}",
-                title=title[:70],
-                company=company[:50],
-                tech_domain=domain,
-                city=city,
-                area=geo[:30] if geo else "Global Remote",
-                salary_min_lpa=salary_min,
-                salary_max_lpa=salary_max,
-                experience_min_years=3,
-                experience_max_years=8,
-                tech_stack=self.extract_tech_keywords(title + " " + desc)[:7],
-                requirements=self.clean_html(desc)[:1000],
-                work_mode="Remote",
-                company_tier="Tech Firm",
-                posted_date=datetime.now().strftime("%Y-%m-%d"),
-                url=job_url
-            ))
-
-        return jobs
-
-    def _scrape_weworkremotely(self) -> List[JobPosting]:
-        url = "https://weworkremotely.com/categories/remote-programming-jobs.rss"
-        resp = requests.get(url, headers=self.headers, timeout=12)
-        if resp.status_code != 200:
-            return []
-
-        soup = BeautifulSoup(resp.text, "html.parser")
-        items = soup.find_all("item")
-        jobs = []
-
-        for idx, item in enumerate(items):
-            title_node = item.find("title")
-            link_node = item.find("link")
-            desc_node = item.find("description")
-
-            full_title = title_node.get_text() if title_node else "Senior Engineer"
-            job_url = link_node.get_text() if link_node else "https://weworkremotely.com"
-            desc = desc_node.get_text() if desc_node else full_title
-
-            parts = full_title.split(":")
-            if len(parts) > 1:
-                company = parts[0].strip()
-                title = parts[1].strip()
-            else:
-                company = "WeWorkRemotely Tech"
-                title = full_title
-
-            domain = self.detect_domain(title, [])
-            salary_min, salary_max = self.extract_salary_lpa(None, None, desc)
-
-            jobs.append(JobPosting(
-                id=f"LIVE-WWR-{idx + 100}",
-                title=title[:70],
-                company=company[:50],
-                tech_domain=domain,
-                city="Remote",
-                area="Global Remote Hub",
-                salary_min_lpa=salary_min,
-                salary_max_lpa=salary_max,
-                experience_min_years=3,
-                experience_max_years=8,
-                tech_stack=self.extract_tech_keywords(title + " " + desc)[:7],
-                requirements=self.clean_html(desc)[:1000],
-                work_mode="Remote",
-                company_tier="Product Tech Leader",
-                posted_date=datetime.now().strftime("%Y-%m-%d"),
-                url=job_url
-            ))
-
-        return jobs
-
-    def detect_domain(self, title: str, tags: List[str]) -> str:
-        text = (title + " " + " ".join(tags)).lower()
-        if any(w in text for w in ["backend", "go", "java", "spring", "microservice", "python"]):
-            return "Backend Engineering"
-        elif any(w in text for w in ["frontend", "react", "next.js", "vue", "typescript", "ui"]):
-            return "Frontend Engineering"
-        elif any(w in text for w in ["full stack", "fullstack", "full-stack"]):
-            return "Full Stack Engineering"
-        elif any(w in text for w in ["devops", "cloud", "aws", "kubernetes", "k8s", "terraform", "sre"]):
-            return "Cloud & DevOps"
-        elif any(w in text for w in ["data", "spark", "snowflake", "kafka", "pipeline", "sql"]):
-            return "Data Engineering"
-        elif any(w in text for w in ["ai", "genai", "llm", "machine learning", "pytorch", "mcp", "cuda"]):
-            return "AI/ML & GenAI"
-        elif any(w in text for w in ["android", "ios", "flutter", "kotlin", "mobile", "swift"]):
-            return "Mobile Engineering"
-        return "Software Engineering"
-
-    def detect_city(self, location: str) -> str:
-        loc = (location or "").lower()
-        if "bengaluru" in loc or "bangalore" in loc:
-            return "Bengaluru"
-        elif "pune" in loc:
-            return "Pune"
-        elif "hyderabad" in loc:
-            return "Hyderabad"
-        elif "gurgaon" in loc or "delhi" in loc or "ncr" in loc:
-            return "Gurgaon"
-        elif "mumbai" in loc:
-            return "Mumbai"
-        elif "chennai" in loc:
-            return "Chennai"
-        return "Remote"
-
-    def extract_salary_lpa(self, sal_min: Optional[float], sal_max: Optional[float], text: str) -> tuple[float, float]:
-        if sal_min and sal_max and sal_min > 1000:
-            # Convert USD to INR LPA (e.g. $100K = ~85 LPA)
-            min_lpa = round((sal_min * 83.5) / 100000.0, 1)
-            max_lpa = round((sal_max * 83.5) / 100000.0, 1)
-            return max(18.0, min_lpa), max(28.0, max_lpa)
-
-        # Regex search for salary numbers in description
-        match = re.search(r'\$(\d{2,3})k?\s*-\s*\$?(\d{2,3})k', text, re.IGNORECASE)
-        if match:
-            s1 = float(match.group(1)) * 1000
-            s2 = float(match.group(2)) * 1000
-            min_lpa = round((s1 * 83.5) / 100000.0, 1)
-            max_lpa = round((s2 * 83.5) / 100000.0, 1)
-            return max(20.0, min_lpa), max(32.0, max_lpa)
-
-        return 26.0, 44.0
-
-    def extract_tech_keywords(self, text: str) -> List[str]:
-        known = [
-            "Go", "Java", "Python", "TypeScript", "React", "Next.js", "Node.js",
-            "FastAPI", "Spring Boot", "Docker", "Kubernetes", "AWS", "Terraform",
-            "PostgreSQL", "Redis", "Kafka", "Apache Spark", "Snowflake",
-            "FastMCP", "MCP", "LangGraph", "PyTorch", "CUDA", "vLLM", "Qdrant",
-            "Kotlin", "Flutter", "Swift", "GraphQL", "gRPC"
-        ]
-        found = []
-        for kw in known:
-            if re.search(r'\b' + re.escape(kw) + r'\b', text, re.IGNORECASE):
-                found.append(kw)
-        return found or ["Python", "Docker", "REST API"]
-
-    def clean_html(self, raw_html: str) -> str:
-        soup = BeautifulSoup(raw_html, "html.parser")
-        return soup.get_text(separator=" ", strip=True)

tech_radar/tech_radar/scrapers/mock_data.py

@@ -1,249 +0,0 @@
-from typing import List
-from tech_radar.db.models import JobPosting
-
-UNIVERSAL_TECH_JOBS: List[JobPosting] = [
-    # BACKEND ENGINEERING
-    JobPosting(
-        id="BLR-BACKEND-101",
-        title="Staff Backend Engineer (Distributed Systems / Go)",
-        company="Uber Tech India",
-        tech_domain="Backend Engineering",
-        city="Bengaluru",
-        area="Bellandur Outer Ring Rd",
-        salary_min_lpa=42.0,
-        salary_max_lpa=68.0,
-        experience_min_years=5,
-        experience_max_years=10,
-        tech_stack=["Go", "gRPC", "Kubernetes", "Apache Kafka", "Cassandra", "Redis", "Distributed Systems"],
-        requirements=(
-            "Join Uber's Core Infrastructure & Dispatch Systems team in Bengaluru. Architect high-concurrency microservices handling "
-            "100K+ QPS using Go and gRPC. Required experience with event-driven streaming (Kafka), distributed storage (Cassandra/CockroachDB), "
-            "and low-latency system design."
-        ),
-        work_mode="Hybrid",
-        company_tier="Product Giant / Tier-1 Enterprise",
-        posted_date="2026-08-06",
-        url="https://uber.com/careers/blr-staff-backend"
-    ),
-    JobPosting(
-        id="PUNE-BACKEND-102",
-        title="Senior Java Microservices Architect",
-        company="Barclays Technology Centre",
-        city="Pune",
-        area="Kharadi EON Free Zone",
-        tech_domain="Backend Engineering",
-        salary_min_lpa=28.0,
-        salary_max_lpa=44.0,
-        experience_min_years=4,
-        experience_max_years=9,
-        tech_stack=["Java 21", "Spring Boot", "Kafka", "PostgreSQL", "Docker", "AWS", "OAuth2"],
-        requirements=(
-            "Barclays Kharadi campus is hiring a Senior Java Architect for core payment processing gateways. "
-            "Must have hands-on expertise with Spring Boot, Java virtual threads, resilience patterns (Resilience4j), PostgreSQL optimization, "
-            "and secure financial REST/gRPC API development."
-        ),
-        work_mode="Hybrid",
-        company_tier="Global Banking Tech R&D",
-        posted_date="2026-08-07",
-        url="https://barclays.com/careers/pune-java-architect"
-    ),
-
-    # FRONTEND & FULL STACK
-    JobPosting(
-        id="BLR-FRONTEND-201",
-        title="Lead Frontend Architect (Next.js & Performance)",
-        company="Cred",
-        tech_domain="Frontend Engineering",
-        city="Bengaluru",
-        area="Indiranagar",
-        salary_min_lpa=38.0,
-        salary_max_lpa=58.0,
-        experience_min_years=4,
-        experience_max_years=8,
-        tech_stack=["React 19", "Next.js", "TypeScript", "TailwindCSS", "Zustand", "WebSockets", "GraphQL"],
-        requirements=(
-            "Cred Bengaluru is seeking a Lead Frontend Architect to drive UI performance across web and mobile web platforms. "
-            "Experience with SSR/SSG in Next.js, micro-frontends, bundle size optimization, responsive design systems, and real-time WebSockets."
-        ),
-        work_mode="On-site",
-        company_tier="Unicorn Tech",
-        posted_date="2026-08-08",
-        url="https://cred.club/careers/lead-frontend"
-    ),
-    JobPosting(
-        id="PUNE-FULLSTACK-202",
-        title="Senior Full Stack Engineer (React + Python FastAPI)",
-        company="Mastercard Tech Hub",
-        city="Pune",
-        area="Kharadi",
-        tech_domain="Full Stack Engineering",
-        salary_min_lpa=26.0,
-        salary_max_lpa=40.0,
-        experience_min_years=3,
-        experience_max_years=7,
-        tech_stack=["React", "TypeScript", "Python", "FastAPI", "PostgreSQL", "Docker", "AWS"],
-        requirements=(
-            "Mastercard Pune is hiring a Senior Full Stack Engineer to build developer portals and payment dashboard tools. "
-            "Requires strong React/TypeScript skills combined with Python FastAPI backend services, Docker containerization, and AWS deployment."
-        ),
-        work_mode="Hybrid",
-        company_tier="Global Tech MNC",
-        posted_date="2026-08-05",
-        url="https://mastercard.com/careers/pune-fullstack"
-    ),
-    JobPosting(
-        id="REMOTE-FULLSTACK-203",
-        title="Staff Full Stack Developer (Next.js & Node.js)",
-        company="GitLab (Remote India)",
-        city="Remote",
-        area="Remote India",
-        tech_domain="Full Stack Engineering",
-        salary_min_lpa=35.0,
-        salary_max_lpa=55.0,
-        experience_min_years=4,
-        experience_max_years=9,
-        tech_stack=["TypeScript", "React", "Next.js", "Node.js", "GraphQL", "PostgreSQL", "Redis"],
-        requirements=(
-            "100% Remote opportunity for Indian engineers. Lead full-stack product development on developer collaboration features. "
-            "Requires mastery of TypeScript, Next.js server components, Node.js GraphQL APIs, and asynchronous message queues."
-        ),
-        work_mode="Remote",
-        company_tier="Global Remote Leader",
-        posted_date="2026-08-08",
-        url="https://gitlab.com/jobs/remote-fullstack"
-    ),
-
-    # CLOUD & DEVOPS
-    JobPosting(
-        id="HYD-DEVOPS-301",
-        title="Principal Cloud & DevOps Infrastructure Engineer",
-        company="Salesforce India R&D",
-        city="Hyderabad",
-        area="HITEC City",
-        tech_domain="Cloud & DevOps",
-        salary_min_lpa=40.0,
-        salary_max_lpa=65.0,
-        experience_min_years=5,
-        experience_max_years=11,
-        tech_stack=["AWS", "Kubernetes", "Terraform", "Helm", "ArgoCD", "Python", "Prometheus", "Grafana"],
-        requirements=(
-            "Salesforce Hyderabad is seeking a Cloud Infrastructure Leader. Drive Kubernetes cluster automation across multi-region AWS environments. "
-            "Must have deep hands-on expertise in Infrastructure-as-Code (Terraform), GitOps with ArgoCD, cluster security, and observability (Prometheus/Jaeger)."
-        ),
-        work_mode="Hybrid",
-        company_tier="Global Enterprise SaaS",
-        posted_date="2026-08-07",
-        url="https://salesforce.com/careers/hyd-devops-principal"
-    ),
-    JobPosting(
-        id="PUNE-DEVOPS-302",
-        title="Senior Site Reliability & Cloud Engineer",
-        company="PTC Software R&D",
-        city="Pune",
-        area="Hinjawadi Phase 1",
-        tech_domain="Cloud & DevOps",
-        salary_min_lpa=24.0,
-        salary_max_lpa=38.0,
-        experience_min_years=3,
-        experience_max_years=7,
-        tech_stack=["Docker", "Kubernetes", "AWS", "Terraform", "Python", "CI/CD GitHub Actions"],
-        requirements=(
-            "PTC Hinjawadi Pune is hiring an SRE / Cloud Engineer. Manage SaaS platform uptime, automate multi-tenant deployment pipelines, "
-            "and maintain infrastructure provisioning using Terraform and Docker Kubernetes stacks."
-        ),
-        work_mode="Hybrid",
-        company_tier="Enterprise CAD/PLM Giant",
-        posted_date="2026-08-04",
-        url="https://ptc.com/careers/pune-sre"
-    ),
-
-    # DATA ENGINEERING & ANALYTICS
-    JobPosting(
-        id="NCR-DATA-401",
-        title="Lead Data Engineer (Spark & Snowflake Platform)",
-        company="Zomato Tech",
-        city="Gurgaon",
-        area="DLF Cyber City",
-        tech_domain="Data Engineering",
-        salary_min_lpa=32.0,
-        salary_max_lpa=50.0,
-        experience_min_years=4,
-        experience_max_years=8,
-        tech_stack=["Apache Spark", "PySpark", "Snowflake", "Kafka", "Airflow", "Python", "SQL"],
-        requirements=(
-            "Zomato Gurgaon R&D is hiring a Data Platform Lead. Build petabyte-scale streaming & batch data pipelines for real-time order dispatch analytics. "
-            "Key tech: Apache Spark, Snowflake, Airflow DAG orchestration, and Kafka stream processing."
-        ),
-        work_mode="Hybrid",
-        company_tier="Indian Consumer Tech Leader",
-        posted_date="2026-08-06",
-        url="https://zomato.com/careers/gurgaon-data-lead"
-    ),
-
-    # AI/ML & GENAI
-    JobPosting(
-        id="PUNE-AIML-501",
-        title="Senior GenAI & FastMCP Systems Engineer",
-        company="NVIDIA India R&D",
-        city="Pune",
-        area="Baner-Pashan",
-        tech_domain="AI/ML & GenAI",
-        salary_min_lpa=35.0,
-        salary_max_lpa=55.0,
-        experience_min_years=3,
-        experience_max_years=7,
-        tech_stack=["FastMCP", "vLLM", "CUDA", "PyTorch", "LangGraph", "Qdrant", "Python"],
-        requirements=(
-            "NVIDIA R&D Pune is hiring an AI Systems Engineer. Build high-throughput LLM serving infrastructure using vLLM "
-            "and expose GPU tool-calling capabilities via Model Context Protocol (MCP). Requires strong Python, PyTorch, CUDA, and RAG vector store experience."
-        ),
-        work_mode="Hybrid",
-        company_tier="Global AI Pioneer",
-        posted_date="2026-08-05",
-        url="https://nvidia.com/careers/pune-genai-mcp"
-    ),
-    JobPosting(
-        id="BLR-AIML-502",
-        title="Staff LLM & Agentic AI Specialist",
-        company="Flipkart AI Labs",
-        city="Bengaluru",
-        area="Electronic City",
-        tech_domain="AI/ML & GenAI",
-        salary_min_lpa=42.0,
-        salary_max_lpa=66.0,
-        experience_min_years=4,
-        experience_max_years=9,
-        tech_stack=["LangGraph", "FastMCP", "Unsloth", "DeepSpeed", "Qdrant", "FastAPI"],
-        requirements=(
-            "Flipkart AI Labs Bengaluru is seeking a Staff Agentic AI Engineer. Build autonomous shopping assistant agents using LangGraph, "
-            "fine-tune Llama-3 models with PEFT/Unsloth, and integrate tool calling via FastMCP protocols."
-        ),
-        work_mode="Hybrid",
-        company_tier="E-Commerce Leader",
-        posted_date="2026-08-08",
-        url="https://flipkart.com/careers/blr-agentic-ai"
-    ),
-
-    # MOBILE ENGINEERING
-    JobPosting(
-        id="CHN-MOBILE-601",
-        title="Lead Android & Mobile Architect (Kotlin/Flutter)",
-        company="Zoho Corporation",
-        city="Chennai",
-        area="Estancia IT Park",
-        tech_domain="Mobile Engineering",
-        salary_min_lpa=25.0,
-        salary_max_lpa=42.0,
-        experience_min_years=4,
-        experience_max_years=8,
-        tech_stack=["Kotlin", "Jetpack Compose", "Flutter", "Android SDK", "Coroutines", "Clean Architecture"],
-        requirements=(
-            "Zoho Chennai is hiring a Mobile Systems Architect. Lead the development of enterprise mobile applications downloaded by millions worldwide. "
-            "Expertise in Kotlin, Jetpack Compose, state management (MVI/MVVM), offline-first architecture, and cross-platform Flutter."
-        ),
-        work_mode="On-site",
-        company_tier="SaaS Pioneer",
-        posted_date="2026-08-03",
-        url="https://zoho.com/careers/chennai-mobile-lead"
-    )
-]

tech_radar/tech_radar/scrapers/seeder.py

@@ -1,36 +0,0 @@
-from tech_radar.db.database import DatabaseManager
-from tech_radar.db.vector_store import SemanticVectorStore
-from tech_radar.scrapers.mock_data import UNIVERSAL_TECH_JOBS
-from tech_radar.scrapers.live_scraper import LiveInternetScraper
-
-def seed_database(db_path: str = "tech_radar.db", fetch_live: bool = True) -> tuple[DatabaseManager, SemanticVectorStore]:
-    """Seed SQLite database and vector store with curated + live real-time internet job postings."""
-    db = DatabaseManager(db_path=db_path)
-    vector_store = SemanticVectorStore()
-
-    count = 0
-    # 1. Seed base curated tech jobs
-    for job in UNIVERSAL_TECH_JOBS:
-        db.save_job_posting(job)
-        count += 1
-
-    # 2. Fetch live real-time internet jobs
-    if fetch_live:
-        try:
-            scraper = LiveInternetScraper()
-            live_jobs = scraper.fetch_all_live_jobs()
-            for l_job in live_jobs:
-                db.save_job_posting(l_job)
-                count += 1
-        except Exception as e:
-            print(f"[Seeder] Live internet scraping warning: {e}")
-
-    all_jobs = db.get_all_jobs()
-    vector_store.index_jobs(all_jobs)
-
-    print(f" Successfully seeded {count} total job postings into {db_path}.")
-    print(f" Indexed {len(all_jobs)} jobs across all domains in Vector Engine.")
-    return db, vector_store
-
-if __name__ == "__main__":
-    seed_database(fetch_live=True)

tech_radar/tech_radar/ui/app.py

@@ -1,340 +0,0 @@
-import streamlit as st
-import pandas as pd
-import plotly.express as px
-import json
-import sys
-import os
-
-sys.path.insert(0, os.path.abspath("."))
-
-from tech_radar.db.database import DatabaseManager
-from tech_radar.db.vector_store import SemanticVectorStore
-from tech_radar.agents.evaluator_agent import EvaluatorAgent
-from tech_radar.agents.market_analyst import MarketAnalystAgent
-from tech_radar.scrapers.seeder import seed_database
-from tech_radar.mcp.tools import (
-    tool_search_tech_jobs,
-    tool_analyze_skill_gap,
-    tool_generate_resume_patch,
-    tool_get_market_insights,
-    tool_generate_interview_prep_kit
-)
-
-st.set_page_config(
-    page_title="TechRadar MCP | 3D Cyber Hiring Intelligence",
-    page_icon="⚡",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
-
-# Custom CSS matching 5718062.jpg reference & Fonts.txt (Bebas Neue + Poppins)
-st.markdown("""
-<style>
-    @import url('https://fonts.googleapis.com/css2?family=Bebas+Neue&family=Poppins:wght@300;400;500;600;700;800&display=swap');
-
-    html, body, [class*="css"] {
-        font-family: 'Poppins', sans-serif;
-    }
-
-    .main-header {
-        font-family: 'Bebas Neue', sans-serif;
-        font-size: 3.2rem;
-        letter-spacing: 3px;
-        background: linear-gradient(90deg, #00e5ff, #9d4edd, #e94057);
-        -webkit-background-clip: text;
-        -webkit-text-fill-color: transparent;
-        margin-bottom: 0.1rem;
-        text-shadow: 0 0 30px rgba(0, 229, 255, 0.3);
-    }
-
-    .sub-header {
-        font-size: 1.05rem;
-        color: #a0aec0;
-        margin-bottom: 1.8rem;
-    }
-
-    /* 3D Glassmorphic Job Cards */
-    .job-card-3d {
-        background: rgba(20, 14, 45, 0.7);
-        backdrop-filter: blur(20px);
-        border: 1px solid rgba(0, 229, 255, 0.25);
-        border-radius: 18px;
-        padding: 24px;
-        margin-bottom: 20px;
-        box-shadow: 0 10px 30px rgba(0,0,0,0.5), inset 0 1px 1px rgba(255, 255, 255, 0.1);
-        transition: all 0.3s ease;
-    }
-
-    .job-card-3d:hover {
-        border-color: #00e5ff;
-        box-shadow: 0 15px 35px rgba(0, 229, 255, 0.3);
-    }
-
-    .badge-cyan {
-        background: rgba(0, 229, 255, 0.15);
-        border: 1px solid rgba(0, 229, 255, 0.4);
-        color: #00e5ff;
-        padding: 4px 12px;
-        border-radius: 50px;
-        font-size: 0.8rem;
-        font-weight: 600;
-    }
-
-    .badge-purple {
-        background: rgba(157, 78, 221, 0.2);
-        border: 1px solid rgba(157, 78, 221, 0.5);
-        color: #d8b4fe;
-        padding: 4px 12px;
-        border-radius: 50px;
-        font-size: 0.8rem;
-        font-weight: 600;
-    }
-
-    .badge-stack {
-        background: rgba(255, 255, 255, 0.06);
-        border: 1px solid rgba(255, 255, 255, 0.12);
-        color: #e2e8f0;
-        padding: 3px 9px;
-        border-radius: 6px;
-        font-size: 0.75rem;
-        margin-right: 6px;
-    }
-
-    .stButton>button {
-        background: linear-gradient(90deg, #00e5ff, #9d4edd);
-        color: white;
-        font-family: 'Poppins', sans-serif;
-        font-weight: 700;
-        border-radius: 50px;
-        border: none;
-        padding: 10px 28px;
-        box-shadow: 0 0 20px rgba(0, 229, 255, 0.4);
-        transition: all 0.3s ease;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-@st.cache_resource
-def load_data_and_engines():
-    return seed_database()
-
-db, vector_store = load_data_and_engines()
-evaluator = EvaluatorAgent()
-market_analyst = MarketAnalystAgent(db)
-
-# Sidebar
-st.sidebar.image("https://raw.githubusercontent.com/modelcontextprotocol/mcp/main/docs/assets/mcp-logo.png", width=120)
-st.sidebar.title("⚡ TechRadar MCP")
-st.sidebar.markdown("**Universal Hiring Intelligence**")
-
-target_domain = st.sidebar.selectbox(
-    "Filter Tech Domain",
-    ["All", "Backend Engineering", "Frontend Engineering", "Full Stack Engineering", "Cloud & DevOps", "Data Engineering", "AI/ML & GenAI", "Mobile Engineering"]
-)
-
-target_city = st.sidebar.selectbox(
-    "Filter City / Region",
-    ["All", "Bengaluru", "Pune", "Hyderabad", "Gurgaon", "Mumbai", "Chennai", "Remote"]
-)
-
-selected_tab = st.sidebar.radio(
-    "Navigation",
-    [
-        "📡 Universal Tech Job Radar",
-        "📊 Market & Salary Analytics",
-        "🎯 ATS Resume & Skill Gap Analyzer",
-        "🧪 Interactive MCP Server Tester"
-    ]
-)
-
-# Header
-st.markdown('<div class="main-header">UNIVERSAL TECH HIRING INTELLIGENCE</div>', unsafe_allow_html=True)
-st.markdown('<div class="sub-header">3D Cyber-Glassmorphic Model Context Protocol Ecosystem across All Tech Domains & Cities</div>', unsafe_allow_html=True)
-
-# TAB 1: TECH JOB RADAR
-if selected_tab == "📡 Universal Tech Job Radar":
-    all_jobs = db.search_jobs(domain=target_domain, city=target_city, limit=300)
-    
-    col1, col2, col3, col4 = st.columns(4)
-    with col1:
-        st.metric("Total Active Jobs", len(all_jobs))
-    with col2:
-        remote_count = len([j for j in all_jobs if j.work_mode.lower() == "remote"])
-        st.metric("Remote Roles", remote_count)
-    with col3:
-        avg_max_sal = round(sum(j.salary_max_lpa for j in all_jobs) / (len(all_jobs) or 1), 1)
-        st.metric("Avg Max Salary", f"₹{avg_max_sal} LPA")
-    with col4:
-        top_sal = max([j.salary_max_lpa for j in all_jobs] or [0])
-        st.metric("Highest Package", f"₹{top_sal} LPA")
-
-    st.divider()
-
-    search_col1, search_col2 = st.columns([3, 1])
-    with search_col1:
-        query = st.text_input("🔍 Semantic Tech Search (e.g., 'Go Distributed Systems Bellandur', 'React Next.js Remote')", "")
-    with search_col2:
-        exp_filter = st.slider("Max Experience (Years)", 0, 12, 10)
-
-    if query:
-        semantic_results = vector_store.search_semantic(query=query, domain=target_domain, city=target_city, top_k=25)
-        jobs_to_display = [j for j, score in semantic_results]
-    else:
-        jobs_to_display = [j for j in all_jobs if j.experience_min_years <= exp_filter]
-
-    st.subheader(f"Showing {len(jobs_to_display)} Matching Roles")
-
-    for job in jobs_to_display:
-        with st.container():
-            st.markdown(f"""
-            <div class="job-card-3d">
-                <div style="display: flex; justify-content: space-between; align-items: center;">
-                    <h3 style="margin: 0; color: #ffffff; font-weight: 700;">{job.title}</h3>
-                    <div>
-                        <span class="badge-cyan">📍 {job.city} ({job.area})</span>
-                        <span class="badge-purple">💻 {job.tech_domain}</span>
-                    </div>
-                </div>
-                <h4 style="margin: 6px 0; color: #cbd5e0;">🏢 {job.company} &nbsp;|&nbsp; 💼 {job.company_tier}</h4>
-                <p style="color: #00ff9d; font-weight: bold; margin: 6px 0;">💰 ₹{job.salary_min_lpa}L - ₹{job.salary_max_lpa}L PA &nbsp;|&nbsp; ⏳ {job.experience_min_years}-{job.experience_max_years} Yrs Exp &nbsp;|&nbsp; 🌐 {job.work_mode}</p>
-                <p style="color: #a0aec0; font-size: 0.9rem; margin-bottom: 12px;">{job.requirements[:280]}...</p>
-                <div style="margin-top: 10px;">
-                    {' '.join([f'<span class="badge-stack">{stack}</span>' for stack in job.tech_stack])}
-                </div>
-                <div style="margin-top: 12px; font-size: 0.8rem; color: #718096;">
-                    <code>Job ID: {job.id}</code> &nbsp;|&nbsp; Posted: {job.posted_date}
-                </div>
-            </div>
-            """, unsafe_allow_html=True)
-
-# TAB 2: MARKET ANALYTICS
-elif selected_tab == "📊 Market & Salary Analytics":
-    st.subheader(f"Market Intelligence Report — {target_domain} ({target_city})")
-    insights = market_analyst.generate_market_report(city=target_city, domain=target_domain)
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown("### 🚀 Hiring Summary")
-        st.write(f"- **Active Roles Tracked**: `{insights.total_active_jobs}`")
-        st.write(f"- **Average Salary**: `{insights.avg_salary_lpa} LPA`")
-        st.write(f"- **Salary Range**: `{insights.salary_range}`")
-        st.info(insights.growth_trend)
-
-        st.markdown("### 🏢 Top Employers Hiring Tech Talent")
-        for emp in insights.top_employers:
-            st.markdown(f"- **{emp}**")
-
-    with col2:
-        st.markdown("### 🔥 Top Demanded Tech Skills & Frameworks")
-        df_frameworks = pd.DataFrame(insights.top_demanded_frameworks)
-        if not df_frameworks.empty:
-            fig = px.bar(
-                df_frameworks,
-                x="percentage",
-                y="skill",
-                orientation="h",
-                title="Skill Demand % in Selected Market",
-                labels={"percentage": "Job Postings Demand (%)", "skill": "Skill"},
-                color="percentage",
-                color_continuous_scale="Purples"
-            )
-            fig.update_layout(darkmode=True, yaxis={'categoryorder':'total ascending'})
-            st.plotly_chart(fig, use_container_width=True)
-
-# TAB 3: ATS RESUME ANALYZER
-elif selected_tab == "🎯 ATS Resume & Skill Gap Analyzer":
-    st.subheader("🎯 Candidate-to-JD Skill Gap & ATS Analyzer")
-
-    col1, col2 = st.columns([1, 1])
-
-    with col1:
-        sample_resume = """
-        SOFTWARE ENGINEER | BENGALURU
-        3+ years experience building backend REST microservices in Go and Python.
-        Built relational databases in PostgreSQL, cached data with Redis, and deployed Docker containers on AWS.
-        Looking for Senior Backend, Full Stack, or Cloud roles across Bengaluru, Pune, and Remote.
-        """
-        resume_input = st.text_area("Paste Candidate Resume Text", sample_resume, height=220)
-        
-        all_jobs = db.get_all_jobs()
-        job_options = {f"{j.id} — {j.title} at {j.company} ({j.city})": j.id for j in all_jobs}
-        selected_job_label = st.selectbox("Select Target Job Opening", list(job_options.keys()))
-        selected_job_id = job_options[selected_job_label]
-        
-        analyze_btn = st.button("🚀 Analyze Skill Gap & Generate Patch", type="primary")
-
-    with col2:
-        if analyze_btn:
-            job = db.get_job_by_id(selected_job_id)
-            report = evaluator.evaluate_skill_gap(resume_text=resume_input, candidate_skills=["Go", "Python", "PostgreSQL", "Redis", "Docker", "AWS"], job=job)
-            patch = evaluator.generate_resume_patch(resume_text=resume_input, job=job)
-            prep = evaluator.generate_interview_prep(job=job)
-
-            st.markdown(f"### Match Score: `{report.match_percentage}%`")
-            st.progress(report.match_percentage / 100.0)
-
-            st.markdown("#### ✅ Matched Skills")
-            st.write(", ".join([f"`{s}`" for s in report.matched_skills]) or "None")
-
-            st.markdown("#### ❌ Missing Skills (Dealbreakers)")
-            st.write(", ".join([f"`{s}`" for s in report.missing_skills]) or "None")
-
-            st.markdown("#### 📝 Tailored ATS Resume Bullets (Diff)")
-            for item in patch.tailored_bullets:
-                st.warning(f"**Original**: {item['original']}\n\n**Tailored**: {item['tailored']}\n\n*Rationale*: {item['rationale']}")
-
-            st.markdown("#### ❓ Sample Technical Interview Question")
-            if prep.technical_questions:
-                q = prep.technical_questions[0]
-                st.info(f"**Q**: {q.question}\n\n**Key Points**: {', '.join(q.ideal_answer_points)}")
-
-# TAB 4: INTERACTIVE MCP TESTER
-elif selected_tab == "🧪 Interactive MCP Server Tester":
-    st.subheader("🧪 Live FastMCP Server Tool Execution Sandbox")
-    st.markdown("Test the exact JSON-RPC response generated by FastMCP tools for Claude Desktop & Cursor.")
-
-    mcp_tool = st.selectbox(
-        "Select MCP Tool",
-        [
-            "search_tech_jobs",
-            "analyze_skill_gap",
-            "generate_tailored_resume_patch",
-            "get_market_insights",
-            "generate_interview_prep_kit"
-        ]
-    )
-
-    if mcp_tool == "search_tech_jobs":
-        c_dom = st.selectbox("domain", ["All", "Backend Engineering", "Frontend Engineering", "Full Stack Engineering", "Cloud & DevOps", "AI/ML & GenAI"])
-        c_city = st.selectbox("city", ["All", "Bengaluru", "Pune", "Hyderabad", "Gurgaon", "Remote"])
-        c_query = st.text_input("query", "Go Distributed Systems")
-        if st.button("Execute Tool"):
-            res = tool_search_tech_jobs(domain=c_dom, city=c_city, query=c_query)
-            st.code(res, language="json")
-
-    elif mcp_tool == "analyze_skill_gap":
-        c_res = st.text_area("resume_text", "Backend developer experienced in Go, Docker, and PostgreSQL.")
-        c_jid = st.text_input("target_job_id", "BLR-BACKEND-101")
-        if st.button("Execute Tool"):
-            res = tool_analyze_skill_gap(resume_text=c_res, target_job_id=c_jid)
-            st.code(res, language="json")
-
-    elif mcp_tool == "generate_tailored_resume_patch":
-        c_res = st.text_area("resume_text", "Built REST APIs in Python.")
-        c_jid = st.text_input("target_job_id", "PUNE-FULLSTACK-202")
-        if st.button("Execute Tool"):
-            res = tool_generate_resume_patch(resume_text=c_res, target_job_id=c_jid)
-            st.code(res, language="json")
-
-    elif mcp_tool == "get_market_insights":
-        c_dom = st.selectbox("domain", ["All", "Backend Engineering", "Frontend Engineering", "Cloud & DevOps"])
-        c_city = st.selectbox("city", ["All", "Bengaluru", "Pune", "Hyderabad"])
-        if st.button("Execute Tool"):
-            res = tool_get_market_insights(domain=c_dom, city=c_city)
-            st.code(res, language="json")
-
-    elif mcp_tool == "generate_interview_prep_kit":
-        c_jid = st.text_input("target_job_id", "BLR-FRONTEND-201")
-        if st.button("Execute Tool"):
-            res = tool_generate_interview_prep_kit(target_job_id=c_jid)
-            st.code(res, language="json")

tech_radar/tech_radar/ui/static_server.py

@@ -1,76 +0,0 @@
-import json
-import os
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import HTMLResponse, JSONResponse
-from pydantic import BaseModel
-from typing import Dict, Any, Optional
-
-from tech_radar.mcp.tools import (
-    get_db_and_vector_store,
-    tool_search_tech_jobs,
-    tool_analyze_skill_gap,
-    tool_generate_resume_patch,
-    tool_get_market_insights,
-    tool_generate_interview_prep_kit
-)
-
-app = FastAPI(title="TechRadar MCP Web Server")
-
-class McpRequest(BaseModel):
-    tool: str
-    args: Dict[str, Any]
-
-@app.get("/", response_class=HTMLResponse)
-def get_web_app():
-    html_path = os.path.join(os.path.dirname(__file__), "web_app.html")
-    if not os.path.exists(html_path):
-        raise HTTPException(status_code=404, detail="web_app.html not found")
-    with open(html_path, "r", encoding="utf-8") as f:
-        return f.read()
-
-@app.get("/api/jobs")
-def get_jobs(domain: Optional[str] = None, city: Optional[str] = None):
-    db, _, _, _ = get_db_and_vector_store()
-    jobs = [j.dict() for j in db.search_jobs(domain=domain, city=city, limit=200)]
-    return {"count": len(jobs), "jobs": jobs}
-
-@app.get("/api/insights")
-def get_insights(city: str = "All", domain: str = "All"):
-    _, _, _, analyst = get_db_and_vector_store()
-    report = analyst.generate_market_report(city=city, domain=domain)
-    return report.dict()
-
-@app.post("/api/mcp/execute")
-def execute_mcp_tool(req: McpRequest):
-    tool_name = req.tool
-    args = req.args
-
-    if tool_name == "search_tech_jobs":
-        res = tool_search_tech_jobs(
-            domain=args.get("domain", "All"),
-            city=args.get("city", "All"),
-            query=args.get("query")
-        )
-    elif tool_name == "analyze_skill_gap":
-        res = tool_analyze_skill_gap(
-            resume_text=args.get("resume_text", ""),
-            target_job_id=args.get("target_job_id", "")
-        )
-    elif tool_name == "generate_tailored_resume_patch":
-        res = tool_generate_resume_patch(
-            resume_text=args.get("resume_text", ""),
-            target_job_id=args.get("target_job_id", "")
-        )
-    elif tool_name == "get_market_insights":
-        res = tool_get_market_insights(
-            domain=args.get("domain", "All"),
-            city=args.get("city", "All")
-        )
-    elif tool_name == "generate_interview_prep_kit":
-        res = tool_generate_interview_prep_kit(
-            target_job_id=args.get("target_job_id", "")
-        )
-    else:
-        raise HTTPException(status_code=400, detail=f"Unknown tool: {tool_name}")
-
-    return {"status": "success", "tool": tool_name, "result": res}

tech_radar/tech_radar/ui/web_app.html

@@ -1,966 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>TechRadar MCP — Universal Tech Hiring Intelligence</title>
-    <!-- Google Fonts: Bebas Neue & Poppins -->
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Bebas+Neue&family=Poppins:wght@300;400;500;600;700;800&display=swap" rel="stylesheet">
-    <!-- Chart.js for Market Analytics -->
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-    <style>
-        :root {
-            --bg-dark: #090514;
-            --bg-card: rgba(20, 14, 45, 0.65);
-            --border-glass: rgba(0, 229, 255, 0.25);
-            --border-glow: #00e5ff;
-            --accent-cyan: #00e5ff;
-            --accent-purple: #9d4edd;
-            --accent-pink: #e94057;
-            --text-main: #f0f4f8;
-            --text-muted: #a0aec0;
-        }
-
-        * {
-            box-sizing: border-box;
-            margin: 0;
-            padding: 0;
-        }
-
-        body {
-            background-color: var(--bg-dark);
-            color: var(--text-main);
-            font-family: 'Poppins', sans-serif;
-            overflow-x: hidden;
-            min-height: 100vh;
-        }
-
-        /* Canvas 3D Cyber Wave Grid Background */
-        #cyber-canvas {
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100vw;
-            height: 100vh;
-            z-index: -1;
-            pointer-events: none;
-        }
-
-        /* Main Wrapper */
-        .app-container {
-            max-width: 1350px;
-            margin: 0 auto;
-            padding: 20px 30px 80px 30px;
-        }
-
-        /* Navbar */
-        .navbar {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            padding: 20px 0;
-            border-bottom: 1px solid rgba(255, 255, 255, 0.08);
-            margin-bottom: 30px;
-        }
-
-        .brand-logo {
-            display: flex;
-            align-items: center;
-            gap: 12px;
-            font-family: 'Bebas Neue', sans-serif;
-            font-size: 2.2rem;
-            letter-spacing: 2px;
-            background: linear-gradient(90deg, #00e5ff, #9d4edd, #e94057);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-        }
-
-        .mcp-status-pill {
-            background: rgba(0, 229, 255, 0.1);
-            border: 1px solid var(--accent-cyan);
-            color: var(--accent-cyan);
-            padding: 6px 16px;
-            border-radius: 50px;
-            font-size: 0.85rem;
-            font-weight: 600;
-            display: flex;
-            align-items: center;
-            gap: 8px;
-            box-shadow: 0 0 15px rgba(0, 229, 255, 0.3);
-        }
-
-        .status-dot {
-            width: 8px;
-            height: 8px;
-            background-color: var(--accent-cyan);
-            border-radius: 50%;
-            animation: pulse-dot 1.5s infinite;
-        }
-
-        @keyframes pulse-dot {
-            0% { transform: scale(0.95); box-shadow: 0 0 0 0 rgba(0, 229, 255, 0.7); }
-            70% { transform: scale(1); box-shadow: 0 0 0 8px rgba(0, 229, 255, 0); }
-            100% { transform: scale(0.95); box-shadow: 0 0 0 0 rgba(0, 229, 255, 0); }
-        }
-
-        /* Hero Banner Section (Inspired by reference 5718062.jpg) */
-        .hero-banner {
-            position: relative;
-            background: linear-gradient(135deg, rgba(20, 14, 50, 0.8) 0%, rgba(10, 6, 30, 0.9) 100%);
-            border: 1px solid var(--border-glass);
-            backdrop-filter: blur(20px);
-            border-radius: 24px;
-            padding: 45px 50px;
-            display: flex;
-            align-items: center;
-            justify-content: space-between;
-            margin-bottom: 40px;
-            box-shadow: 0 20px 50px rgba(0, 0, 0, 0.6), inset 0 1px 1px rgba(255, 255, 255, 0.15);
-            overflow: hidden;
-        }
-
-        .hero-banner::before {
-            content: '';
-            position: absolute;
-            top: -50%;
-            right: -10%;
-            width: 400px;
-            height: 400px;
-            background: radial-gradient(circle, rgba(157, 78, 221, 0.3) 0%, transparent 70%);
-            pointer-events: none;
-        }
-
-        .hero-text {
-            max-width: 650px;
-            z-index: 2;
-        }
-
-        .hero-tag {
-            text-transform: uppercase;
-            font-size: 0.9rem;
-            letter-spacing: 3px;
-            color: var(--accent-cyan);
-            font-weight: 700;
-            margin-bottom: 10px;
-        }
-
-        .hero-title {
-            font-family: 'Bebas Neue', sans-serif;
-            font-size: 4rem;
-            line-height: 1;
-            letter-spacing: 3px;
-            margin-bottom: 15px;
-            background: linear-gradient(90deg, #ffffff, #e2e8f0);
-            -webkit-background-clip: text;
-            -webkit-text-fill-color: transparent;
-            text-shadow: 0 0 30px rgba(0, 229, 255, 0.3);
-        }
-
-        .hero-subtitle {
-            font-size: 1.05rem;
-            color: var(--text-muted);
-            margin-bottom: 25px;
-            line-height: 1.6;
-        }
-
-        .btn-gradient {
-            background: linear-gradient(90deg, var(--accent-cyan), var(--accent-purple));
-            color: white;
-            padding: 14px 34px;
-            border-radius: 50px;
-            font-size: 0.95rem;
-            font-weight: 700;
-            border: none;
-            cursor: pointer;
-            text-transform: uppercase;
-            letter-spacing: 1px;
-            transition: all 0.3s ease;
-            box-shadow: 0 0 25px rgba(0, 229, 255, 0.4);
-            display: inline-flex;
-            align-items: center;
-            gap: 10px;
-        }
-
-        .btn-gradient:hover {
-            transform: translateY(-3px) scale(1.02);
-            box-shadow: 0 0 35px rgba(157, 78, 221, 0.6);
-        }
-
-        /* 3D Visual Orb / Graphics */
-        .hero-graphic {
-            position: relative;
-            width: 320px;
-            height: 220px;
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            z-index: 2;
-        }
-
-        .orb-ring {
-            position: absolute;
-            border-radius: 50%;
-            border: 2px dashed rgba(0, 229, 255, 0.4);
-            animation: spin 20s linear infinite;
-        }
-
-        .orb-ring-1 { width: 220px; height: 220px; border-color: rgba(0, 229, 255, 0.5); }
-        .orb-ring-2 { width: 170px; height: 170px; border-color: rgba(157, 78, 221, 0.6); animation-direction: reverse; animation-duration: 15s; }
-
-        .orb-core {
-            width: 110px;
-            height: 110px;
-            border-radius: 50%;
-            background: radial-gradient(circle at 30% 30%, #00e5ff, #9d4edd 70%, #090514);
-            box-shadow: 0 0 50px rgba(0, 229, 255, 0.6);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-family: 'Bebas Neue', sans-serif;
-            font-size: 2rem;
-            color: white;
-            text-shadow: 0 0 10px rgba(255, 255, 255, 0.8);
-        }
-
-        @keyframes spin {
-            from { transform: rotate(0deg); }
-            to { transform: rotate(360deg); }
-        }
-
-        /* Controls & Filter Bar */
-        .filter-section {
-            background: var(--bg-card);
-            backdrop-filter: blur(15px);
-            border: 1px solid var(--border-glass);
-            border-radius: 16px;
-            padding: 20px 25px;
-            margin-bottom: 30px;
-            display: flex;
-            flex-wrap: wrap;
-            gap: 20px;
-            align-items: center;
-            justify-content: space-between;
-        }
-
-        .filter-group {
-            display: flex;
-            align-items: center;
-            gap: 10px;
-            flex-wrap: wrap;
-        }
-
-        .filter-label {
-            font-size: 0.85rem;
-            font-weight: 600;
-            color: var(--text-muted);
-            text-transform: uppercase;
-            letter-spacing: 1px;
-        }
-
-        .pill-btn {
-            background: rgba(255, 255, 255, 0.05);
-            border: 1px solid rgba(255, 255, 255, 0.1);
-            color: var(--text-main);
-            padding: 8px 16px;
-            border-radius: 30px;
-            font-size: 0.85rem;
-            font-weight: 500;
-            cursor: pointer;
-            transition: all 0.25s ease;
-        }
-
-        .pill-btn:hover, .pill-btn.active {
-            background: linear-gradient(90deg, rgba(0, 229, 255, 0.2), rgba(157, 78, 221, 0.2));
-            border-color: var(--accent-cyan);
-            color: white;
-            box-shadow: 0 0 15px rgba(0, 229, 255, 0.3);
-        }
-
-        .search-input {
-            background: rgba(10, 6, 25, 0.8);
-            border: 1px solid var(--border-glass);
-            color: white;
-            padding: 10px 20px;
-            border-radius: 30px;
-            font-size: 0.9rem;
-            width: 280px;
-            outline: none;
-            transition: all 0.3s ease;
-        }
-
-        .search-input:focus {
-            border-color: var(--accent-cyan);
-            box-shadow: 0 0 20px rgba(0, 229, 255, 0.4);
-        }
-
-        /* Navigation Tabs */
-        .tab-menu {
-            display: flex;
-            gap: 15px;
-            margin-bottom: 30px;
-            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
-            padding-bottom: 10px;
-        }
-
-        .tab-item {
-            font-family: 'Bebas Neue', sans-serif;
-            font-size: 1.5rem;
-            letter-spacing: 1.5px;
-            color: var(--text-muted);
-            cursor: pointer;
-            padding: 8px 16px;
-            border-radius: 8px;
-            transition: all 0.3s ease;
-        }
-
-        .tab-item:hover, .tab-item.active {
-            color: var(--accent-cyan);
-            background: rgba(0, 229, 255, 0.08);
-            text-shadow: 0 0 10px rgba(0, 229, 255, 0.5);
-        }
-
-        /* Tab Content Panes */
-        .tab-pane {
-            display: none;
-        }
-
-        .tab-pane.active {
-            display: block;
-        }
-
-        /* Job Grid & 3D Glass Cards */
-        .job-grid {
-            display: grid;
-            grid-template-columns: repeat(auto-fill, minmax(380px, 1fr));
-            gap: 25px;
-        }
-
-        .job-card-3d {
-            background: var(--bg-card);
-            backdrop-filter: blur(20px);
-            border: 1px solid var(--border-glass);
-            border-radius: 20px;
-            padding: 25px;
-            transition: transform 0.3s ease, box-shadow 0.3s ease, border-color 0.3s ease;
-            position: relative;
-            overflow: hidden;
-            transform-style: preserve-3d;
-            perspective: 1000px;
-        }
-
-        .job-card-3d:hover {
-            transform: translateY(-8px) rotateX(2deg) rotateY(-2deg);
-            border-color: var(--accent-cyan);
-            box-shadow: 0 20px 40px rgba(0, 0, 0, 0.6), 0 0 30px rgba(0, 229, 255, 0.3);
-        }
-
-        .job-card-header {
-            display: flex;
-            justify-content: space-between;
-            align-items: flex-start;
-            margin-bottom: 12px;
-        }
-
-        .job-title {
-            font-family: 'Poppins', sans-serif;
-            font-size: 1.2rem;
-            font-weight: 700;
-            color: #ffffff;
-            line-height: 1.3;
-        }
-
-        .badge-location {
-            background: rgba(0, 229, 255, 0.15);
-            border: 1px solid rgba(0, 229, 255, 0.4);
-            color: var(--accent-cyan);
-            padding: 4px 10px;
-            border-radius: 12px;
-            font-size: 0.75rem;
-            font-weight: 600;
-            white-space: nowrap;
-        }
-
-        .job-company {
-            font-size: 0.9rem;
-            color: var(--text-muted);
-            margin-bottom: 12px;
-            display: flex;
-            align-items: center;
-            gap: 8px;
-        }
-
-        .job-salary {
-            font-size: 1rem;
-            font-weight: 700;
-            color: #00ff9d;
-            margin-bottom: 12px;
-        }
-
-        .job-desc {
-            font-size: 0.85rem;
-            color: #cbd5e0;
-            line-height: 1.5;
-            margin-bottom: 15px;
-            display: -webkit-box;
-            -webkit-line-clamp: 3;
-            -webkit-box-orient: vertical;
-            overflow: hidden;
-        }
-
-        .stack-tags {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 6px;
-            margin-bottom: 15px;
-        }
-
-        .stack-tag {
-            background: rgba(255, 255, 255, 0.06);
-            border: 1px solid rgba(255, 255, 255, 0.12);
-            color: var(--text-main);
-            padding: 3px 8px;
-            border-radius: 6px;
-            font-size: 0.75rem;
-        }
-
-        .job-card-footer {
-            display: flex;
-            justify-content: space-between;
-            align-items: center;
-            font-size: 0.75rem;
-            color: var(--text-muted);
-            border-top: 1px solid rgba(255, 255, 255, 0.08);
-            padding-top: 12px;
-        }
-
-        /* ATS & Skill Gap Section */
-        .analyzer-container {
-            display: grid;
-            grid-template-columns: 1fr 1fr;
-            gap: 30px;
-        }
-
-        .analyzer-box {
-            background: var(--bg-card);
-            backdrop-filter: blur(20px);
-            border: 1px solid var(--border-glass);
-            border-radius: 20px;
-            padding: 30px;
-        }
-
-        .form-label {
-            font-size: 0.9rem;
-            font-weight: 600;
-            color: var(--text-muted);
-            margin-bottom: 8px;
-            display: block;
-        }
-
-        .form-textarea {
-            width: 100%;
-            height: 180px;
-            background: rgba(10, 6, 25, 0.8);
-            border: 1px solid var(--border-glass);
-            border-radius: 12px;
-            padding: 15px;
-            color: white;
-            font-family: 'Poppins', sans-serif;
-            font-size: 0.85rem;
-            outline: none;
-            resize: vertical;
-            margin-bottom: 15px;
-        }
-
-        .form-select {
-            width: 100%;
-            background: rgba(10, 6, 25, 0.8);
-            border: 1px solid var(--border-glass);
-            border-radius: 10px;
-            padding: 12px;
-            color: white;
-            font-family: 'Poppins', sans-serif;
-            font-size: 0.85rem;
-            outline: none;
-            margin-bottom: 20px;
-        }
-
-        .score-circle {
-            width: 110px;
-            height: 110px;
-            border-radius: 50%;
-            border: 4px solid var(--accent-cyan);
-            box-shadow: 0 0 25px rgba(0, 229, 255, 0.5);
-            display: flex;
-            align-items: center;
-            justify-content: center;
-            font-family: 'Bebas Neue', sans-serif;
-            font-size: 2.5rem;
-            color: var(--accent-cyan);
-            margin: 0 auto 20px auto;
-        }
-
-        .diff-card {
-            background: rgba(255, 255, 255, 0.03);
-            border: 1px solid rgba(255, 204, 0, 0.3);
-            border-radius: 10px;
-            padding: 12px 15px;
-            margin-bottom: 12px;
-            font-size: 0.85rem;
-        }
-
-        .diff-original { color: #eb5757; margin-bottom: 4px; }
-        .diff-tailored { color: #27ae60; font-weight: 600; }
-
-        /* JSON Output Box */
-        .json-box {
-            background: #05030a;
-            border: 1px solid var(--border-glass);
-            border-radius: 12px;
-            padding: 15px;
-            font-family: 'Courier New', Courier, monospace;
-            font-size: 0.85rem;
-            color: #00e5ff;
-            max-height: 400px;
-            overflow-y: auto;
-            white-space: pre-wrap;
-        }
-    </style>
-</head>
-<body>
-
-    <!-- 3D Cyber Mesh Canvas Background -->
-    <canvas id="cyber-canvas"></canvas>
-
-    <div class="app-container">
-        <!-- Top Navbar -->
-        <div class="navbar">
-            <div class="brand-logo">⚡ TECHRADAR MCP</div>
-            <div class="mcp-status-pill">
-                <span class="status-dot"></span> FASTMCP SERVER ACTIVE (STDIO/SSE)
-            </div>
-        </div>
-
-        <!-- Hero Banner (3D Glassmorphism, matching 5718062.jpg) -->
-        <div class="hero-banner">
-            <div class="hero-text">
-                <div class="hero-tag">MODEL CONTEXT PROTOCOL ECOSYSTEM</div>
-                <h1 class="hero-title">UNIVERSAL TECH HIRING INTELLIGENCE</h1>
-                <p class="hero-subtitle">
-                    Autonomous AI job market intelligence, AST skill-gap evaluation, and ATS resume patching across Bengaluru, Pune, Hyderabad, Gurgaon, Mumbai & Remote tech hubs.
-                </p>
-                <button class="btn-gradient" onclick="switchTab('radar')">
-                    🚀 EXPLORE TECH RADAR
-                </button>
-            </div>
-            <div class="hero-graphic">
-                <div class="orb-ring orb-ring-1"></div>
-                <div class="orb-ring orb-ring-2"></div>
-                <div class="orb-core">MCP AI</div>
-            </div>
-        </div>
-
-        <!-- Filter Controls -->
-        <div class="filter-section">
-            <div class="filter-group">
-                <span class="filter-label">Domain:</span>
-                <button class="pill-btn active" onclick="filterDomain('All', this)">ALL DOMAINS</button>
-                <button class="pill-btn" onclick="filterDomain('Backend Engineering', this)">BACKEND</button>
-                <button class="pill-btn" onclick="filterDomain('Frontend Engineering', this)">FRONTEND</button>
-                <button class="pill-btn" onclick="filterDomain('Full Stack Engineering', this)">FULL STACK</button>
-                <button class="pill-btn" onclick="filterDomain('Cloud & DevOps', this)">DEVOPS</button>
-                <button class="pill-btn" onclick="filterDomain('AI/ML & GenAI', this)">AI / GENAI</button>
-            </div>
-
-            <div class="filter-group">
-                <span class="filter-label">City:</span>
-                <button class="pill-btn active" onclick="filterCity('All', this)">ALL CITIES</button>
-                <button class="pill-btn" onclick="filterCity('Bengaluru', this)">BLR</button>
-                <button class="pill-btn" onclick="filterCity('Pune', this)">PUNE</button>
-                <button class="pill-btn" onclick="filterCity('Hyderabad', this)">HYD</button>
-                <button class="pill-btn" onclick="filterCity('Remote', this)">REMOTE</button>
-            </div>
-
-            <input type="text" id="searchInput" class="search-input" placeholder="🔍 Search Go, React, vLLM..." onkeyup="handleSearch()">
-        </div>
-
-        <!-- Navigation Tabs -->
-        <div class="tab-menu">
-            <div class="tab-item active" onclick="switchTab('radar', this)">📡 UNIVERSAL TECH RADAR</div>
-            <div class="tab-item" onclick="switchTab('analytics', this)">📊 MARKET ANALYTICS</div>
-            <div class="tab-item" onclick="switchTab('ats', this)">🎯 ATS SKILL GAP EVALUATOR</div>
-            <div class="tab-item" onclick="switchTab('mcp', this)">🧪 FASTMCP SERVER TESTER</div>
-        </div>
-
-        <!-- TAB 1: RADAR GRID -->
-        <div id="tab-radar" class="tab-pane active">
-            <div class="job-grid" id="jobGrid">
-                <!-- Rendered dynamically via JS -->
-            </div>
-        </div>
-
-        <!-- TAB 2: ANALYTICS -->
-        <div id="tab-analytics" class="tab-pane">
-            <div class="analyzer-container">
-                <div class="analyzer-box">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px; color: var(--accent-cyan);">🔥 TOP DEMANDED TECH FRAMEWORKS</h3>
-                    <canvas id="skillsChart" height="220"></canvas>
-                </div>
-                <div class="analyzer-box">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px; color: var(--accent-purple);">🏢 MAJOR TECH HIRING HUBS</h3>
-                    <canvas id="hubsChart" height="220"></canvas>
-                </div>
-            </div>
-        </div>
-
-        <!-- TAB 3: ATS ANALYZER -->
-        <div id="tab-ats" class="tab-pane">
-            <div class="analyzer-container">
-                <div class="analyzer-box">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px;">INPUT CANDIDATE PROFILE</h3>
-                    <label class="form-label">Paste Resume Text:</label>
-                    <textarea id="resumeInput" class="form-textarea">Senior Backend Engineer with 4 years experience building Go microservices, REST APIs, and Docker containers in Bengaluru. Seeking Senior Go or Distributed Systems roles.</textarea>
-                    
-                    <label class="form-label">Select Target Job Opening:</label>
-                    <select id="jobSelect" class="form-select"></select>
-
-                    <button class="btn-gradient" style="width: 100%; justify-content: center;" onclick="runAtsEvaluation()">
-                        🚀 EVALUATE ATS MATCH & SKILL GAP
-                    </button>
-                </div>
-
-                <div class="analyzer-box" id="atsResultBox">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px; text-align: center;">EVALUATION RESULT</h3>
-                    <div class="score-circle" id="matchScore">--</div>
-                    
-                    <h4 style="font-size: 0.95rem; margin-bottom: 5px; color: #00ff9d;">✅ Matched Skills:</h4>
-                    <p id="matchedSkills" style="font-size: 0.85rem; color: var(--text-muted); margin-bottom: 15px;">-</p>
-
-                    <h4 style="font-size: 0.95rem; margin-bottom: 5px; color: #eb5757;">❌ Missing Skills (Dealbreakers):</h4>
-                    <p id="missingSkills" style="font-size: 0.85rem; color: var(--text-muted); margin-bottom: 20px;">-</p>
-
-                    <h4 style="font-size: 0.95rem; margin-bottom: 10px; color: var(--accent-cyan);">📝 ATS Tailored Resume Bullets:</h4>
-                    <div id="tailoredBullets"></div>
-                </div>
-            </div>
-        </div>
-
-        <!-- TAB 4: MCP TESTER -->
-        <div id="tab-mcp" class="tab-pane">
-            <div class="analyzer-container">
-                <div class="analyzer-box">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px;">SELECT FASTMCP TOOL</h3>
-                    <select id="mcpToolSelect" class="form-select" onchange="updateMcpInputs()">
-                        <option value="search_tech_jobs">search_tech_jobs</option>
-                        <option value="analyze_skill_gap">analyze_skill_gap</option>
-                        <option value="generate_tailored_resume_patch">generate_tailored_resume_patch</option>
-                        <option value="get_market_insights">get_market_insights</option>
-                        <option value="generate_interview_prep_kit">generate_interview_prep_kit</option>
-                    </select>
-
-                    <div id="mcpInputFields"></div>
-
-                    <button class="btn-gradient" style="width: 100%; justify-content: center;" onclick="executeMcpTool()">
-                        ⚡ EXECUTE FASTMCP TOOL
-                    </button>
-                </div>
-
-                <div class="analyzer-box">
-                    <h3 style="font-family: 'Bebas Neue', sans-serif; font-size: 1.8rem; margin-bottom: 15px; color: var(--accent-cyan);">JSON-RPC TOOL OUTPUT</h3>
-                    <div class="json-box" id="mcpJsonOutput">// Execute an MCP tool to view response</div>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <!-- Scripts for 3D Mesh Canvas & App Logic -->
-    <script>
-        // 1. Interactive 3D Cyber Dot Mesh Canvas (Matching 5718062.jpg)
-        const canvas = document.getElementById('cyber-canvas');
-        const ctx = canvas.getContext('2d');
-        let width = canvas.width = window.innerWidth;
-        let height = canvas.height = window.innerHeight;
-
-        window.addEventListener('resize', () => {
-            width = canvas.width = window.innerWidth;
-            height = canvas.height = window.innerHeight;
-        });
-
-        const dots = [];
-        const spacing = 45;
-        for (let x = 0; x < width + spacing; x += spacing) {
-            for (let y = 0; y < height + spacing; y += spacing) {
-                dots.push({
-                    baseX: x,
-                    baseY: y,
-                    x: x,
-                    y: y,
-                    angle: Math.random() * Math.PI * 2,
-                    speed: 0.02 + Math.random() * 0.02
-                });
-            }
-        }
-
-        let mouseX = width / 2;
-        let mouseY = height / 2;
-
-        window.addEventListener('mousemove', (e) => {
-            mouseX = e.clientX;
-            mouseY = e.clientY;
-        });
-
-        function animateCanvas() {
-            ctx.clearRect(0, 0, width, height);
-
-            dots.forEach(dot => {
-                dot.angle += dot.speed;
-                const dist = Math.hypot(mouseX - dot.baseX, mouseY - dot.baseY);
-                const maxDist = 200;
-                let offset = Math.sin(dot.angle) * 4;
-
-                if (dist < maxDist) {
-                    offset += (1 - dist / maxDist) * 15;
-                }
-
-                ctx.fillStyle = dist < 150 ? 'rgba(0, 229, 255, 0.4)' : 'rgba(157, 78, 221, 0.15)';
-                ctx.beginPath();
-                ctx.arc(dot.baseX, dot.baseY + offset, dist < 150 ? 2 : 1.2, 0, Math.PI * 2);
-                ctx.fill();
-            });
-
-            requestAnimationFrame(animateCanvas);
-        }
-        animateCanvas();
-
-        // 2. State & API Fetching Logic
-        let allJobs = [];
-        let currentDomain = 'All';
-        let currentCity = 'All';
-
-        async function fetchJobs() {
-            try {
-                const res = await fetch('/api/jobs');
-                const data = await res.json();
-                allJobs = data.jobs || [];
-                renderJobs();
-                populateJobSelect();
-                initCharts();
-            } catch (err) {
-                console.error("Failed to load jobs:", err);
-            }
-        }
-
-        function renderJobs() {
-            const grid = document.getElementById('jobGrid');
-            grid.innerHTML = '';
-
-            const filtered = allJobs.filter(j => {
-                const domainMatch = currentDomain === 'All' || j.tech_domain === currentDomain;
-                const cityMatch = currentCity === 'All' || j.city.toLowerCase() === currentCity.toLowerCase();
-                return domainMatch && cityMatch;
-            });
-
-            if (filtered.length === 0) {
-                grid.innerHTML = `<div style="grid-column: 1/-1; text-align: center; color: var(--text-muted); padding: 40px;">No matching tech roles found for selected filters.</div>`;
-                return;
-            }
-
-            filtered.forEach(job => {
-                const card = document.createElement('div');
-                card.className = 'job-card-3d';
-                card.innerHTML = `
-                    <div class="job-card-header">
-                        <h3 class="job-title">${job.title}</h3>
-                        <span class="badge-location">📍 ${job.city}</span>
-                    </div>
-                    <div class="job-company">🏢 ${job.company} &bull; <span style="color: var(--accent-cyan);">${job.tech_domain}</span></div>
-                    <div class="job-salary">💰 ₹${job.salary_min_lpa}L - ₹${job.salary_max_lpa}L PA &nbsp;|&nbsp; ⏳ ${job.experience_min_years}-${job.experience_max_years} Yrs</div>
-                    <p class="job-desc">${job.requirements}</p>
-                    <div class="stack-tags">
-                        ${job.tech_stack.map(s => `<span class="stack-tag">${s}</span>`).join('')}
-                    </div>
-                    <div class="job-card-footer">
-                        <span>Job ID: <code>${job.id}</code></span>
-                        <span style="color: #00ff9d;">🌐 ${job.work_mode}</span>
-                    </div>
-                `;
-
-                // 3D Card Hover Perspective Effect
-                card.addEventListener('mousemove', (e) => {
-                    const rect = card.getBoundingClientRect();
-                    const x = e.clientX - rect.left - rect.width / 2;
-                    const y = e.clientY - rect.top - rect.height / 2;
-                    card.style.transform = `perspective(1000px) rotateX(${-y / 15}deg) rotateY(${x / 15}deg) translateY(-5px)`;
-                });
-
-                card.addEventListener('mouseleave', () => {
-                    card.style.transform = `perspective(1000px) rotateX(0deg) rotateY(0deg) translateY(0)`;
-                });
-
-                grid.appendChild(card);
-            });
-        }
-
-        function filterDomain(domain, el) {
-            currentDomain = domain;
-            document.querySelectorAll('.filter-group:nth-child(1) .pill-btn').forEach(b => b.classList.remove('active'));
-            el.classList.add('active');
-            renderJobs();
-        }
-
-        function filterCity(city, el) {
-            currentCity = city;
-            document.querySelectorAll('.filter-group:nth-child(2) .pill-btn').forEach(b => b.classList.remove('active'));
-            el.classList.add('active');
-            renderJobs();
-        }
-
-        function handleSearch() {
-            const query = document.getElementById('searchInput').value.toLowerCase();
-            const cards = document.querySelectorAll('.job-card-3d');
-            cards.forEach(card => {
-                const text = card.innerText.toLowerCase();
-                card.style.display = text.includes(query) ? 'block' : 'none';
-            });
-        }
-
-        function switchTab(tabId, el) {
-            document.querySelectorAll('.tab-pane').forEach(p => p.classList.remove('active'));
-            document.querySelectorAll('.tab-item').forEach(t => t.classList.remove('active'));
-            
-            document.getElementById(`tab-${tabId}`).classList.add('active');
-            if (el) el.classList.add('active');
-        }
-
-        function populateJobSelect() {
-            const sel = document.getElementById('jobSelect');
-            sel.innerHTML = allJobs.map(j => `<option value="${j.id}">${j.id} — ${j.title} at ${j.company} (${j.city})</option>`).join('');
-        }
-
-        async function runAtsEvaluation() {
-            const resumeText = document.getElementById('resumeInput').value;
-            const targetJobId = document.getElementById('jobSelect').value;
-
-            try {
-                const res = await fetch('/api/mcp/execute', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ tool: 'analyze_skill_gap', args: { resume_text: resumeText, target_job_id: targetJobId } })
-                });
-                const data = await res.json();
-                const report = JSON.parse(data.result);
-
-                document.getElementById('matchScore').innerText = `${report.match_percentage}%`;
-                document.getElementById('matchedSkills').innerText = report.matched_skills.join(', ') || 'None';
-                document.getElementById('missingSkills').innerText = report.missing_skills.join(', ') || 'None';
-
-                // Fetch Patch
-                const patchRes = await fetch('/api/mcp/execute', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ tool: 'generate_tailored_resume_patch', args: { resume_text: resumeText, target_job_id: targetJobId } })
-                });
-                const patchData = await patchRes.json();
-                const patch = JSON.parse(patchData.result);
-
-                document.getElementById('tailoredBullets').innerHTML = patch.tailored_bullets.map(b => `
-                    <div class="diff-card">
-                        <div class="diff-original">Original: ${b.original}</div>
-                        <div class="diff-tailored">Tailored: ${b.tailored}</div>
-                    </div>
-                `).join('');
-            } catch (err) {
-                console.error("Evaluation failed:", err);
-            }
-        }
-
-        function updateMcpInputs() {
-            const tool = document.getElementById('mcpToolSelect').value;
-            const fields = document.getElementById('mcpInputFields');
-            if (tool === 'search_tech_jobs') {
-                fields.innerHTML = `
-                    <label class="form-label">domain:</label><input id="arg_domain" class="search-input" style="width:100%; margin-bottom:10px;" value="Backend Engineering">
-                    <label class="form-label">city:</label><input id="arg_city" class="search-input" style="width:100%; margin-bottom:10px;" value="Bengaluru">
-                    <label class="form-label">query:</label><input id="arg_query" class="search-input" style="width:100%; margin-bottom:15px;" value="Go">
-                `;
-            } else {
-                fields.innerHTML = `
-                    <label class="form-label">target_job_id:</label><input id="arg_job_id" class="search-input" style="width:100%; margin-bottom:15px;" value="${allJobs[0]?.id || 'BLR-BACKEND-101'}">
-                `;
-            }
-        }
-
-        async function executeMcpTool() {
-            const tool = document.getElementById('mcpToolSelect').value;
-            let args = {};
-            if (tool === 'search_tech_jobs') {
-                args = {
-                    domain: document.getElementById('arg_domain').value,
-                    city: document.getElementById('arg_city').value,
-                    query: document.getElementById('arg_query').value
-                };
-            } else {
-                args = {
-                    target_job_id: document.getElementById('arg_job_id').value,
-                    resume_text: "Senior backend developer experienced in Go, Docker, AWS."
-                };
-            }
-
-            try {
-                const res = await fetch('/api/mcp/execute', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ tool: tool, args: args })
-                });
-                const data = await res.json();
-                document.getElementById('mcpJsonOutput').innerText = JSON.stringify(JSON.parse(data.result), null, 2);
-            } catch (err) {
-                document.getElementById('mcpJsonOutput').innerText = "Error executing tool: " + err;
-            }
-        }
-
-        function initCharts() {
-            const skillsCtx = document.getElementById('skillsChart').getContext('2d');
-            new Chart(skillsCtx, {
-                type: 'bar',
-                data: {
-                    labels: ['Go', 'React', 'Kubernetes', 'Python', 'FastMCP', 'Spark'],
-                    datasets: [{
-                        label: 'Skill Demand %',
-                        data: [85, 78, 72, 90, 65, 55],
-                        backgroundColor: 'rgba(0, 229, 255, 0.6)',
-                        borderColor: '#00e5ff',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    plugins: { legend: { display: false } },
-                    scales: { y: { ticks: { color: '#a0aec0' } }, x: { ticks: { color: '#a0aec0' } } }
-                }
-            });
-
-            const hubsCtx = document.getElementById('hubsChart').getContext('2d');
-            new Chart(hubsCtx, {
-                type: 'doughnut',
-                data: {
-                    labels: ['Bengaluru', 'Pune', 'Hyderabad', 'Gurgaon', 'Remote'],
-                    datasets: [{
-                        data: [40, 25, 20, 10, 5],
-                        backgroundColor: ['#00e5ff', '#9d4edd', '#e94057', '#00ff9d', '#ffcc00']
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    plugins: { legend: { labels: { color: '#a0aec0' } } }
-                }
-            });
-        }
-
-        // Initialize
-        fetchJobs();
-        updateMcpInputs();
-    </script>
-</body>
-</html>