Upload career_os_orchestrator.py

career_os_orchestrator.py

@@ -0,0 +1,523 @@
+"""
+═══════════════════════════════════════════════════════════════════════════════
+ CAREER OS — MULTI-AGENT ORCHESTRATOR
+═══════════════════════════════════════════════════════════════════════════════
+
+Hierarchical multi-agent architecture inspired by AgentOrchestra (arXiv:2506.12508).
+Each agent is a fine-tuned model specialized for one career domain.
+The Orchestrator Agent delegates tasks and synthesizes outputs.
+
+Agents:
+  1. Resume Parser — PDF/text → structured JSON
+  2. Job Matcher — resume ↔ job description matching & scoring
+  3. Career Advisor — path planning, skill gap analysis, interview prep
+  4. Salary Negotiator — compensation strategies, market research
+  5. Orchestrator — routes requests, manages context, synthesizes responses
+
+Usage (Colab A100):
+  !pip install -q transformers peft accelerate
+  from career_os_orchestrator import CareerOS
+  cos = CareerOS(agent_model="Builder-Neekhil/career-agent-v1")
+  result = cos.process("Review my resume for a Senior PM role", resume_text)
+  print(result)
+
+Or with individual agents:
+  cos.agents["resume_parser"].parse(pdf_path)
+  cos.agents["job_matcher"].score(resume, job_description)
+═══════════════════════════════════════════════════════════════════════════════
+"""
+
+import json, re, os
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from peft import PeftModel
+
+
+@dataclass
+class ParsedResume:
+    """Structured resume output."""
+    name: str = ""
+    email: str = ""
+    phone: str = ""
+    summary: str = ""
+    experience: List[Dict] = None
+    education: List[Dict] = None
+    skills: List[str] = None
+    certifications: List[str] = None
+    raw: str = ""
+
+    def __post_init__(self):
+        if self.experience is None:
+            self.experience = []
+        if self.education is None:
+            self.education = []
+        if self.skills is None:
+            self.skills = []
+        if self.certifications is None:
+            self.certifications = []
+
+
+@dataclass
+class JobFitResult:
+    """Job fit assessment result."""
+    fit_assessment: str = ""
+    score: int = 0
+    strengths: List[str] = None
+    gaps: List[str] = None
+    suggestions: List[str] = None
+    raw: str = ""
+
+    def __post_init__(self):
+        if self.strengths is None:
+            self.strengths = []
+        if self.gaps is None:
+            self.gaps = []
+        if self.suggestions is None:
+            self.suggestions = []
+
+
+class CareerAgent:
+    """Base class for all career agents."""
+
+    def __init__(self, model_name: str, system_prompt: str, device: str = "auto"):
+        self.model_name = model_name
+        self.system_prompt = system_prompt
+        self.device = device
+        self.tokenizer = None
+        self.model = None
+        self.pipe = None
+        self._loaded = False
+
+    def load(self):
+        if self._loaded:
+            return
+        print(f"[AGENT] Loading {self.model_name}...")
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, trust_remote_code=True)
+        if self.tokenizer.pad_token is None:
+            self.tokenizer.pad_token = self.tokenizer.eos_token
+
+        self.model = AutoModelForCausalLM.from_pretrained(
+            self.model_name,
+            torch_dtype=torch.bfloat16,
+            device_map=self.device,
+            trust_remote_code=True,
+        )
+        self.pipe = pipeline(
+            "text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            max_new_tokens=1024,
+            temperature=0.7,
+            do_sample=True,
+            top_p=0.9,
+        )
+        self._loaded = True
+        print(f"[AGENT] {self.model_name} loaded.")
+
+    def generate(self, user_prompt: str, max_new_tokens: int = 1024) -> str:
+        if not self._loaded:
+            self.load()
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": user_prompt},
+        ]
+        outputs = self.pipe(messages, max_new_tokens=max_new_tokens, return_full_text=False)
+        return outputs[0]["generated_text"]
+
+
+class ResumeParserAgent(CareerAgent):
+    """Extract structured data from resume text."""
+
+    SYSTEM = (
+        "You are an expert resume parser. Extract ALL information from the provided resume "
+        "and return ONLY valid JSON with these exact fields: name, email, phone, summary, "
+        "experience (array of {title, company, dates, description}), "
+        "education (array of {degree, institution, year}), skills (array), certifications (array). "
+        "No explanation, no markdown formatting — only JSON."
+    )
+
+    def __init__(self, model_name: str, device: str = "auto"):
+        super().__init__(model_name, self.SYSTEM, device)
+
+    def parse(self, resume_text: str) -> ParsedResume:
+        prompt = f"Parse the following resume into structured JSON:\n\n{resume_text}"
+        raw = self.generate(prompt, max_new_tokens=2048)
+
+        # Extract JSON
+        json_match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if json_match:
+            try:
+                data = json.loads(json_match.group())
+                return ParsedResume(
+                    name=data.get("name", ""),
+                    email=data.get("email", ""),
+                    phone=data.get("phone", ""),
+                    summary=data.get("summary", ""),
+                    experience=data.get("experience", []),
+                    education=data.get("education", []),
+                    skills=data.get("skills", []),
+                    certifications=data.get("certifications", []),
+                    raw=raw,
+                )
+            except json.JSONDecodeError:
+                pass
+
+        return ParsedResume(raw=raw)
+
+
+class JobMatcherAgent(CareerAgent):
+    """Match resume to job description."""
+
+    SYSTEM = (
+        "You are a senior technical recruiter with 15 years of experience. "
+        "Assess how well a candidate's resume matches a job description. "
+        "Return ONLY valid JSON with: fit_assessment ('Good Fit', 'Partial Fit', 'No Fit'), "
+        "score (0-100), strengths (array), gaps (array), suggestions (array)."
+    )
+
+    def __init__(self, model_name: str, device: str = "auto"):
+        super().__init__(model_name, self.SYSTEM, device)
+
+    def score(self, resume_text: str, job_description: str) -> JobFitResult:
+        prompt = (
+            f"Resume:\n{resume_text}\n\n"
+            f"Job Description:\n{job_description}\n\n"
+            f"Task: Assess fit. Return JSON only."
+        )
+        raw = self.generate(prompt, max_new_tokens=1024)
+
+        json_match = re.search(r'\{.*\}', raw, re.DOTALL)
+        if json_match:
+            try:
+                data = json.loads(json_match.group())
+                return JobFitResult(
+                    fit_assessment=data.get("fit_assessment", ""),
+                    score=data.get("score", 0),
+                    strengths=data.get("strengths", []),
+                    gaps=data.get("gaps", []),
+                    suggestions=data.get("suggestions", []),
+                    raw=raw,
+                )
+            except json.JSONDecodeError:
+                pass
+
+        return JobFitResult(raw=raw)
+
+
+class CareerAdvisorAgent(CareerAgent):
+    """Career path planning, skill gap analysis, interview prep."""
+
+    SYSTEM = (
+        "You are a career advisor with 15 years of experience. "
+        "Provide actionable, specific career guidance. Include concrete next steps, timelines, "
+        "and measurable goals. Use structured formats (bullet points, numbered lists, markdown headers)."
+    )
+
+    def __init__(self, model_name: str, device: str = "auto"):
+        super().__init__(model_name, self.SYSTEM, device)
+
+    def suggest_path(self, resume_text: str, target_role: Optional[str] = None) -> str:
+        prompt = f"Given this resume, what are 3-5 next career steps?\n\n{resume_text}"
+        if target_role:
+            prompt += f"\n\nTarget role: {target_role}"
+        return self.generate(prompt)
+
+    def interview_prep(self, resume_text: str, role: str) -> str:
+        prompt = f"Based on this {role} resume, generate 5 interview questions with preparation tips.\n\n{resume_text}"
+        return self.generate(prompt)
+
+    def skill_gap_analysis(self, resume_text: str, target_role: str) -> str:
+        prompt = f"Compare this resume to the requirements for {target_role}. What skills need development?\n\n{resume_text}"
+        return self.generate(prompt)
+
+
+class SalaryNegotiatorAgent(CareerAgent):
+    """Salary negotiation strategies."""
+
+    SYSTEM = (
+        "You are a compensation negotiation expert. Provide specific, data-backed strategies. "
+        "Include market rate research, anchoring techniques, total compensation framing, "
+        "and role-play scripts. Be direct and practical."
+    )
+
+    def __init__(self, model_name: str, device: str = "auto"):
+        super().__init__(model_name, self.SYSTEM, device)
+
+    def strategy(self, current_salary: int, target_role: str, location: str,
+                 years_experience: int) -> str:
+        prompt = (
+            f"Current salary: ${current_salary}\n"
+            f"Target role: {target_role}\n"
+            f"Location: {location}\n"
+            f"Years of experience: {years_experience}\n\n"
+            f"Provide a complete salary negotiation strategy including market research, "
+            f"anchoring techniques, total comp framing, and a ready-to-use script."
+        )
+        return self.generate(prompt, max_new_tokens=2048)
+
+
+class CareerOS:
+    """
+    Orchestrator for the multi-agent Career OS.
+    Routes tasks to specialized agents and synthesizes outputs.
+    """
+
+    SYSTEM = (
+        "You are the Career OS Orchestrator. You manage a team of specialized career agents:\n"
+        "- Resume Parser: extracts structured data from resumes\n"
+        "- Job Matcher: assesses resume-job fit\n"
+        "- Career Advisor: suggests paths, prepares interviews, analyzes skill gaps\n"
+        "- Salary Negotiator: provides compensation strategies\n\n"
+        "Your job is to understand the user's request, delegate to the right agent(s), "
+        "and synthesize a comprehensive, actionable response. When multiple agents are needed, "
+        "call them sequentially and combine their outputs into a single coherent answer."
+    )
+
+    def __init__(self, agent_model: str = "Builder-Neekhil/career-agent-v1",
+                 device: str = "auto", lazy_load: bool = True):
+        self.agent_model = agent_model
+        self.device = device
+        self.agents: Dict[str, CareerAgent] = {
+            "resume_parser": ResumeParserAgent(agent_model, device),
+            "job_matcher": JobMatcherAgent(agent_model, device),
+            "career_advisor": CareerAdvisorAgent(agent_model, device),
+            "salary_negotiator": SalaryNegotiatorAgent(agent_model, device),
+        }
+        if not lazy_load:
+            for agent in self.agents.values():
+                agent.load()
+
+    def process(self, user_request: str, resume_text: Optional[str] = None,
+                job_description: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Main entry point. Routes to appropriate agents based on the request.
+        Returns a dict with all agent outputs and a synthesized response.
+        """
+        result = {
+            "request": user_request,
+            "agents_called": [],
+            "raw_outputs": {},
+            "synthesized": "",
+        }
+
+        # Route based on intent detection
+        request_lower = user_request.lower()
+
+        # --- RESUME REVIEW ---
+        if any(kw in request_lower for kw in ["review", "feedback", "improve", "resume"]):
+            if resume_text:
+                parsed = self.agents["resume_parser"].parse(resume_text)
+                result["raw_outputs"]["parsed_resume"] = {
+                    "name": parsed.name,
+                    "skills": parsed.skills,
+                    "experience_count": len(parsed.experience),
+                }
+                result["agents_called"].append("resume_parser")
+
+                advisor = self.agents["career_advisor"]
+                review = advisor.generate(
+                    f"Please review this resume and give actionable feedback:\n\n{resume_text}"
+                )
+                result["raw_outputs"]["resume_review"] = review
+                result["agents_called"].append("career_advisor")
+
+                result["synthesized"] = review
+
+        # --- JOB FIT ASSESSMENT ---
+        elif any(kw in request_lower for kw in ["fit", "match", "job", "description"]):
+            if resume_text and job_description:
+                fit_result = self.agents["job_matcher"].score(resume_text, job_description)
+                result["raw_outputs"]["job_fit"] = {
+                    "score": fit_result.score,
+                    "assessment": fit_result.fit_assessment,
+                    "strengths": fit_result.strengths,
+                    "gaps": fit_result.gaps,
+                    "suggestions": fit_result.suggestions,
+                }
+                result["agents_called"].append("job_matcher")
+
+                # Also get career advice on closing gaps
+                gap_analysis = self.agents["career_advisor"].skill_gap_analysis(
+                    resume_text, job_description[:200]
+                )
+                result["raw_outputs"]["gap_analysis"] = gap_analysis
+                result["agents_called"].append("career_advisor")
+
+                result["synthesized"] = (
+                    f"## Job Fit Assessment\n\n"
+                    f"**Score:** {fit_result.score}/100 — {fit_result.fit_assessment}\n\n"
+                    f"**Strengths:**\n" + "\n".join(f"- {s}" for s in fit_result.strengths) + "\n\n"
+                    f"**Gaps:**\n" + "\n".join(f"- {g}" for g in fit_result.gaps) + "\n\n"
+                    f"**Suggestions:**\n" + "\n".join(f"- {s}" for s in fit_result.suggestions) + "\n\n"
+                    f"**Gap Analysis:**\n{gap_analysis[:500]}..."
+                )
+
+        # --- CAREER PATH ---
+        elif any(kw in request_lower for kw in ["career path", "next steps", "future", "grow"]):
+            if resume_text:
+                path = self.agents["career_advisor"].suggest_path(resume_text)
+                result["raw_outputs"]["career_path"] = path
+                result["agents_called"].append("career_advisor")
+                result["synthesized"] = path
+
+        # --- INTERVIEW PREP ---
+        elif any(kw in request_lower for kw in ["interview", "questions", "prep"]):
+            role = self._extract_role(user_request)
+            if resume_text:
+                prep = self.agents["career_advisor"].interview_prep(resume_text, role or "professional")
+                result["raw_outputs"]["interview_prep"] = prep
+                result["agents_called"].append("career_advisor")
+                result["synthesized"] = prep
+
+        # --- SALARY NEGOTIATION ---
+        elif any(kw in request_lower for kw in ["salary", "negotiate", "compensation", "offer"]):
+            # Try to extract info from context
+            strategy = self.agents["salary_negotiator"].strategy(
+                current_salary=100000,
+                target_role="Senior Software Engineer",
+                location="San Francisco, CA",
+                years_experience=5,
+            )
+            result["raw_outputs"]["salary_strategy"] = strategy
+            result["agents_called"].append("salary_negotiator")
+            result["synthesized"] = strategy
+
+        # --- DEFAULT: FULL CAREER CONSULTATION ---
+        else:
+            if resume_text and job_description:
+                # Full pipeline
+                parsed = self.agents["resume_parser"].parse(resume_text)
+                fit = self.agents["job_matcher"].score(resume_text, job_description)
+                path = self.agents["career_advisor"].suggest_path(resume_text)
+
+                result["raw_outputs"]["parsed_resume"] = parsed.__dict__
+                result["raw_outputs"]["job_fit"] = fit.__dict__
+                result["raw_outputs"]["career_path"] = path
+                result["agents_called"].extend(["resume_parser", "job_matcher", "career_advisor"])
+
+                result["synthesized"] = (
+                    f"## Career OS Full Report\n\n"
+                    f"### 1. Resume Summary\n"
+                    f"- **Name:** {parsed.name}\n"
+                    f"- **Skills:** {', '.join(parsed.skills[:5])}\n"
+                    f"- **Experience:** {len(parsed.experience)} roles\n\n"
+                    f"### 2. Job Fit\n"
+                    f"- **Score:** {fit.score}/100 ({fit.fit_assessment})\n\n"
+                    f"### 3. Career Path\n"
+                    f"{path[:800]}..."
+                )
+            else:
+                # Direct response
+                result["synthesized"] = self.agents["career_advisor"].generate(user_request)
+                result["agents_called"].append("career_advisor")
+
+        return result
+
+    def _extract_role(self, text: str) -> Optional[str]:
+        """Extract role name from request text."""
+        common_roles = [
+            "software engineer", "data scientist", "product manager",
+            "designer", "marketing manager", "sales manager", "analyst",
+            "consultant", "engineer", "manager", "director", "vp"
+        ]
+        text_lower = text.lower()
+        for role in common_roles:
+            if role in text_lower:
+                return role.title()
+        return None
+
+    def full_pipeline(self, resume_text: str, job_description: Optional[str] = None,
+                      target_role: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Run the complete Career OS pipeline:
+        Parse → Match (if JD) → Path → Interview Prep
+        """
+        print("[CAREER OS] Running full pipeline...")
+        results = {}
+
+        # 1. Parse resume
+        print("[1/4] Parsing resume...")
+        parsed = self.agents["resume_parser"].parse(resume_text)
+        results["parsed_resume"] = parsed
+
+        # 2. Match to job
+        if job_description:
+            print("[2/4] Matching to job description...")
+            fit = self.agents["job_matcher"].score(resume_text, job_description)
+            results["job_fit"] = fit
+        else:
+            print("[2/4] Skipping job match (no JD provided)...")
+
+        # 3. Career path
+        print("[3/4] Generating career path...")
+        path = self.agents["career_advisor"].suggest_path(resume_text, target_role)
+        results["career_path"] = path
+
+        # 4. Interview prep
+        role = target_role or parsed.experience[0].get("title", "professional") if parsed.experience else "professional"
+        print(f"[4/4] Generating interview prep for {role}...")
+        prep = self.agents["career_advisor"].interview_prep(resume_text, role)
+        results["interview_prep"] = prep
+
+        print("[CAREER OS] Pipeline complete!")
+        return results
+
+
+# ── CLI DEMO ──────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", default="Builder-Neekhil/career-agent-v1")
+    parser.add_argument("--task", default="review", choices=["review", "fit", "path", "interview", "full"])
+    parser.add_argument("--resume", default="")
+    parser.add_argument("--job", default="")
+    args = parser.parse_args()
+
+    cos = CareerOS(agent_model=args.model)
+
+    demo_resume = args.resume or (
+        "John Doe\nSoftware Engineer\n5 years experience in Python, React, AWS. "
+        "Built REST APIs with FastAPI and microservices. Led a team of 3 developers. "
+        "BSc Computer Science, Stanford University.\n"
+        "Skills: Python, JavaScript, AWS, Docker, Kubernetes, PostgreSQL, Redis\n"
+        "Certifications: AWS Solutions Architect, Certified Scrum Master"
+    )
+
+    demo_job = args.job or (
+        "Senior Software Engineer\nRequirements:\n- 5+ years Python experience\n"
+        "- Microservices architecture\n- Team leadership\n- AWS/GCP\n- Docker, Kubernetes\n"
+        "- BSc in Computer Science or equivalent"
+    )
+
+    if args.task == "review":
+        result = cos.process("Review my resume", resume_text=demo_resume)
+        print(result["synthesized"])
+
+    elif args.task == "fit":
+        result = cos.process("Assess job fit", resume_text=demo_resume, job_description=demo_job)
+        print(result["synthesized"])
+
+    elif args.task == "path":
+        result = cos.process("Career path", resume_text=demo_resume)
+        print(result["synthesized"])
+
+    elif args.task == "interview":
+        result = cos.process("Interview prep", resume_text=demo_resume)
+        print(result["synthesized"])
+
+    elif args.task == "full":
+        results = cos.full_pipeline(demo_resume, demo_job)
+        print("\n=== PARSED RESUME ===")
+        print(f"Name: {results['parsed_resume'].name}")
+        print(f"Skills: {results['parsed_resume'].skills}")
+        if 'job_fit' in results:
+            print(f"\n=== JOB FIT ===")
+            print(f"Score: {results['job_fit'].score}/100")
+        print(f"\n=== CAREER PATH ===")
+        print(results['career_path'][:500])
+        print(f"\n=== INTERVIEW PREP ===")
+        print(results['interview_prep'][:500])