Update application file

app.py

@@ -6,15 +6,15 @@ An AI agent that autonomously analyzes job postings and candidate profiles
 to create tailored application documents using multi-step reasoning.
 
 Author: Career Agent Team
-Version: 1.0
+Version: 1.1 - SambaNova Edition
 """
 
 import os
 import logging
 import gradio as gr
-from typing import Optional
+from typing import Optional, Dict, Any
 from dotenv import load_dotenv
-from smolagents import CodeAgent, tool, HfApiModel, ChatMessage
+from openai import OpenAI
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -23,82 +23,96 @@ logger = logging.getLogger(__name__)
 # Load environment variables
 load_dotenv()
 
-# === Tools ===
+# === SambaNova API Integration ===
 
-@tool
-def analyze_candidate_profile(user_info: str) -> str:
-    """
-    Analyzes the candidate's profile to extract insights and positioning.
+class SambaNovaClient:
+    """SambaNova client using OpenAI SDK."""
+    
+    def __init__(self, api_key: str, model_name: str = "Meta-Llama-3.3-70B-Instruct"):
+        self.client = OpenAI(
+            api_key=api_key,
+            base_url="https://api.sambanova.ai/v1"
+        )
+        self.model_name = model_name
+        
+    def generate(self, prompt: str, system_prompt: str = "You are a helpful assistant.") -> str:
+        """Generate response using SambaNova API."""
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model_name,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.1,
+                top_p=0.1,
+                max_tokens=3000
+            )
+            
+            return response.choices[0].message.content or ""
+            
+        except Exception as e:
+            logger.error(f"SambaNova API call failed: {e}")
+            return f"❌ API Error: {str(e)}"
 
-    Args:
-        user_info (str): Full professional profile including experience, skills, education.
+# === Analysis Functions ===
 
-    Returns:
-        str: Structured professional assessment.
-    """
+def analyze_candidate_profile(client: SambaNovaClient, user_info: str) -> str:
+    """Analyzes the candidate's profile to extract insights and positioning."""
+    system_prompt = "You are a senior career strategist with expertise in talent assessment and professional positioning."
+    
     prompt = f"""
-    As a senior career strategist, analyze this candidate profile:
+    Analyze this candidate profile in detail:
 
     {user_info}
 
-    Provide detailed analysis including:
-    - Experience level and career stage
-    - Core competencies and unique strengths
+    Provide a comprehensive analysis including:
+    - Experience level and career stage assessment
+    - Core competencies and unique value propositions
     - Industry expertise and domain knowledge
-    - Leadership and soft skills indicators
-    - Potential career trajectory
-    - Areas for strategic positioning
+    - Leadership capabilities and soft skills evidence
+    - Career trajectory and growth potential
+    - Strategic positioning opportunities
+    - Areas of competitive advantage
 
-    Format as structured professional assessment.
+    Format your response as a structured professional assessment with clear sections.
     """
-    return call_model(prompt)
+    
+    return client.generate(prompt, system_prompt)
 
 
-@tool
-def research_job_posting(job_description: str) -> str:
-    """
-    Analyzes the job posting for strategic application guidance.
-
-    Args:
-        job_description (str): Full job description as provided by the employer.
-
-    Returns:
-        str: Structured analysis of employer needs and expectations.
-    """
+def research_job_posting(client: SambaNovaClient, job_description: str) -> str:
+    """Analyzes the job posting for strategic application guidance."""
+    system_prompt = "You are an expert recruiter and talent acquisition specialist with deep knowledge of job market trends."
+    
     prompt = f"""
-    Conduct comprehensive job posting analysis:
+    Conduct a comprehensive analysis of this job posting:
 
     {job_description}
 
     Extract and analyze:
-    - Required vs preferred qualifications
-    - Technical skills and experience requirements
-    - Company culture and values indicators
-    - Role challenges and key responsibilities
-    - Growth and advancement opportunities
-    - Compensation and benefits signals
-    - ATS keywords and phrases
-    - Hiring urgency indicators
-
-    Provide strategic intelligence for application optimization.
-    """
-    return call_model(prompt)
-
-
-@tool
-def assess_fit_and_strategy(profile_analysis: str, job_research: str) -> str:
+    - Must-have vs nice-to-have qualifications
+    - Technical skills and experience requirements breakdown
+    - Company culture indicators and values alignment
+    - Key responsibilities and success metrics
+    - Career growth and advancement signals
+    - Compensation and benefits analysis
+    - Critical ATS keywords and industry terminology
+    - Hiring urgency and competition level indicators
+    - Decision-maker priorities and pain points
+
+    Provide strategic intelligence for optimal application positioning.
     """
-    Evaluates fit between the candidate and job, and suggests strategy.
+    
+    return client.generate(prompt, system_prompt)
 
-    Args:
-        profile_analysis (str): Output from profile analysis.
-        job_research (str): Output from job posting analysis.
 
-    Returns:
-        str: Application strategy with fit assessment and messaging plan.
-    """
+def assess_fit_and_strategy(client: SambaNovaClient, profile_analysis: str, job_research: str) -> str:
+    """Evaluates fit between candidate and job, develops application strategy."""
+    system_prompt = "You are a strategic career consultant specializing in job application optimization and candidate positioning."
+    
     prompt = f"""
-    Strategic fit assessment and application strategy:
+    Based on the candidate analysis and job research below, develop a comprehensive application strategy:
 
     CANDIDATE ANALYSIS:
     {profile_analysis}
@@ -106,31 +120,26 @@ def assess_fit_and_strategy(profile_analysis: str, job_research: str) -> str:
     JOB INTELLIGENCE:
     {job_research}
 
-    Provide comprehensive assessment:
-    - Overall fit percentage with detailed reasoning
-    - Strongest selling points to emphasize
-    - Potential weaknesses and mitigation strategies
+    Provide detailed strategic assessment:
+    - Overall fit percentage with detailed justification
+    - Top 5 strongest selling points to emphasize
+    - Potential concerns and mitigation strategies
     - Unique value proposition development
-    - Competitive positioning recommendations
-    - Application approach and messaging strategy
-    """
-    return call_model(prompt)
-
-
-@tool
-def generate_strategic_resume(candidate_info: str, strategy: str) -> str:
+    - Competitive differentiation approach
+    - Key messaging themes and positioning
+    - Recommended application tone and style
+    - Interview preparation insights
     """
-    Generates a tailored, ATS-optimized resume.
+    
+    return client.generate(prompt, system_prompt)
 
-    Args:
-        candidate_info (str): Raw professional data.
-        strategy (str): Strategic direction from analysis.
 
-    Returns:
-        str: Full resume text.
-    """
+def generate_strategic_resume(client: SambaNovaClient, candidate_info: str, strategy: str) -> str:
+    """Generates a tailored, ATS-optimized resume."""
+    system_prompt = "You are a professional resume writer and ATS optimization expert with extensive experience in creating winning resumes."
+    
     prompt = f"""
-    Create a professional, ATS-optimized resume:
+    Create a professional, ATS-optimized resume based on:
 
     CANDIDATE INFORMATION:
     {candidate_info}
@@ -138,30 +147,26 @@ def generate_strategic_resume(candidate_info: str, strategy: str) -> str:
     STRATEGIC GUIDANCE:
     {strategy}
 
-    Generate complete resume with:
-    - Compelling professional summary
-    - Work experience with quantified achievements
-    - Skills section optimized for job requirements
+    Generate a complete resume with:
+    - Compelling professional summary (3-4 lines)
+    - Core competencies/skills section optimized for ATS
+    - Professional experience with quantified achievements
     - Education and certifications
-    - Additional relevant sections
-    """
-    return call_model(prompt)
+    - Additional relevant sections (projects, awards, etc.)
 
-
-@tool
-def create_cover_letter(candidate_info: str, strategy: str) -> str:
+    Format professionally with clear sections and bullet points.
+    Focus on impact, metrics, and value delivery.
     """
-    Generates a persuasive, personalized cover letter.
+    
+    return client.generate(prompt, system_prompt)
 
-    Args:
-        candidate_info (str): Raw professional data.
-        strategy (str): Strategic direction from analysis.
 
-    Returns:
-        str: Cover letter content.
-    """
+def create_cover_letter(client: SambaNovaClient, candidate_info: str, strategy: str, job_description: str) -> str:
+    """Generates a persuasive, personalized cover letter."""
+    system_prompt = "You are an expert cover letter writer specializing in compelling, personalized application letters that get results."
+    
     prompt = f"""
-    Craft a persuasive cover letter:
+    Write a persuasive cover letter based on:
 
     CANDIDATE INFORMATION:
     {candidate_info}
@@ -169,31 +174,29 @@ def create_cover_letter(candidate_info: str, strategy: str) -> str:
     STRATEGIC POSITIONING:
     {strategy}
 
-    Write engaging cover letter that:
-    - Opens with compelling hook
-    - Demonstrates company/role research
-    - Connects experience to value delivery
-    - Shows cultural fit and enthusiasm
-    - Closes with confident call-to-action
-    """
-    return call_model(prompt)
+    JOB DESCRIPTION:
+    {job_description}
 
+    Create an engaging cover letter that:
+    - Opens with a compelling hook that grabs attention
+    - Demonstrates specific research about the company/role
+    - Connects candidate experience to concrete value delivery
+    - Shows cultural fit and genuine enthusiasm
+    - Addresses potential concerns proactively
+    - Closes with a confident, action-oriented call-to-action
 
-@tool
-def quality_assurance_check(resume: str, cover_letter: str, job_posting: str) -> str:
+    Keep it concise (3-4 paragraphs) but impactful.
     """
-    Runs quality review of generated documents.
+    
+    return client.generate(prompt, system_prompt)
 
-    Args:
-        resume (str): The generated resume.
-        cover_letter (str): The generated cover letter.
-        job_posting (str): Original job description.
 
-    Returns:
-        str: Quality feedback and suggestions.
-    """
+def quality_assurance_check(client: SambaNovaClient, resume: str, cover_letter: str, job_posting: str) -> str:
+    """Performs quality review of generated documents."""
+    system_prompt = "You are a senior HR professional and application reviewer with expertise in document quality assessment."
+    
     prompt = f"""
-    Quality assurance review:
+    Perform a comprehensive quality review of these application materials:
 
     RESUME:
     {resume}
@@ -204,156 +207,299 @@ def quality_assurance_check(resume: str, cover_letter: str, job_posting: str) ->
     ORIGINAL JOB POSTING:
     {job_posting}
 
-    Evaluate:
-    - Keyword alignment and ATS optimization
-    - Document consistency and coherence
-    - Value proposition clarity
-    - Competitive differentiation
-    - Overall application strength
+    Evaluate and provide feedback on:
+    - ATS optimization and keyword alignment (score /10)
+    - Document consistency and professional presentation (score /10)
+    - Value proposition clarity and impact (score /10)
+    - Competitive differentiation strength (score /10)
+    - Overall application effectiveness (score /10)
 
-    Provide a quality score and specific improvement recommendations.
+    Provide specific improvement recommendations and an overall quality assessment.
     """
-    return call_model(prompt)
-
+    
+    return client.generate(prompt, system_prompt)
 
-# === Core ===
-
-def call_model(prompt: str) -> str:
-    """Helper function to call the Hugging Face model."""
-    try:
-        messages = [ChatMessage(role="user", content=prompt)]
-        response = career_agent.model(messages)
-        return str(response.content) if hasattr(response, "content") else "⚠️ Model error"
-    except Exception as e:
-        logger.error(f"Model call failed: {e}")
-        return f"⚠️ Error: {str(e)}"
 
+# === Main Career Agent Class ===
 
 class CareerAgent:
     """Main Career Agent class handling AI-powered document generation."""
 
     def __init__(self):
-        self.model = self._initialize_model()
-        self.agent = self._create_agent()
-
-    def _initialize_model(self) -> HfApiModel:
-        token = os.getenv("HF_TOKEN")
-        if not token:
-            raise ValueError("HF_TOKEN environment variable is required.")
-        return HfApiModel(model_id="meta-llama/Llama-3.1-8B-Instruct", token=token)
-
-    def _create_agent(self) -> CodeAgent:
-        return CodeAgent(
-            model=self.model,
-            tools=[
-                analyze_candidate_profile,
-                research_job_posting,
-                assess_fit_and_strategy,
-                generate_strategic_resume,
-                create_cover_letter,
-                quality_assurance_check
-            ],
-            add_base_tools=True
-        )
+        self.client = self._initialize_client()
+
+    def _initialize_client(self) -> SambaNovaClient:
+        """Initialize SambaNova client."""
+        api_key = os.getenv("SAMBANOVA_API_KEY")
+        if not api_key:
+            raise ValueError("SAMBANOVA_API_KEY environment variable is required.")
+        return SambaNovaClient(api_key=api_key)
 
     def process_application(self, user_info: str, job_description: str) -> str:
+        """Process the complete application with step-by-step analysis."""
         if not user_info.strip() or not job_description.strip():
             return "❌ Please provide both your profile and the job description."
 
-        instruction = f"""
-        You are an expert career strategist.
-
-        CANDIDATE PROFILE:
-        {user_info}
-
-        JOB POSTING:
-        {job_description}
-
-        Follow this process:
-        1. Analyze candidate
-        2. Research job
-        3. Assess fit
-        4. Generate resume
-        5. Generate cover letter
-        6. Quality review
-
-        Output sections:
-        === RESUME ===
-        ...
-        === COVER LETTER ===
-        ...
-        === STRATEGY NOTES ===
-        ...
-        """
-
         try:
-            logger.info("Running career agent process...")
-            result = self.agent.run(instruction)
-            return str(result)
+            logger.info("🔍 Step 1: Analyzing candidate profile...")
+            profile_analysis = analyze_candidate_profile(self.client, user_info)
+            
+            logger.info("🔍 Step 2: Researching job requirements...")
+            job_research = research_job_posting(self.client, job_description)
+            
+            logger.info("🎯 Step 3: Assessing fit and developing strategy...")
+            strategy = assess_fit_and_strategy(self.client, profile_analysis, job_research)
+            
+            logger.info("📄 Step 4: Generating tailored resume...")
+            resume = generate_strategic_resume(self.client, user_info, strategy)
+            
+            logger.info("✉️ Step 5: Creating personalized cover letter...")
+            cover_letter = create_cover_letter(self.client, user_info, strategy, job_description)
+            
+            logger.info("✅ Step 6: Performing quality assurance...")
+            qa_review = quality_assurance_check(self.client, resume, cover_letter, job_description)
+
+            # Format final output
+            result = f"""
+=== 📄 TAILORED RESUME ===
+
+{resume}
+
+=== ✉️ PERSONALIZED COVER LETTER ===
+
+{cover_letter}
+
+=== 🎯 STRATEGIC ANALYSIS ===
+
+{strategy}
+
+=== ✅ QUALITY ASSURANCE REVIEW ===
+
+{qa_review}
+
+---
+Generated by SambaNova Llama 3.3 70B Instruct
+"""
+            
+            logger.info("✅ Application processing completed successfully!")
+            return result.strip()
+            
         except Exception as e:
             logger.error(f"Processing error: {e}")
-            return f"❌ Error: {str(e)}"
+            return f"""❌ SambaNova API Error: {str(e)}
+
+🔧 Troubleshooting:
+- Verify your SAMBANOVA_API_KEY is valid
+- Check your internet connection
+- Ensure you have sufficient API credits
+- Try again in a few moments
+
+If the problem persists, please check your API key configuration."""
 
 
-# === Gradio Interface ===
+# === Enhanced Gradio Interface ===
 
 class CareerAgentInterface:
     def __init__(self, agent: CareerAgent):
         self.agent = agent
 
     def create_interface(self) -> gr.Blocks:
-        with gr.Blocks(title="🎯 Intelligent Career Agent", css=self._css()) as demo:
-            gr.HTML("<h1 style='text-align:center;'>🎯 Intelligent Career Agent</h1>")
-
-            with gr.Row():
-                with gr.Column():
+        """Create enhanced side-by-side interface."""
+        with gr.Blocks(title="🎯 Intelligent Career Agent (SambaNova)", css=self._css()) as demo:
+            # Header
+            gr.Markdown("""
+            # 🎯 Intelligent Career Agent
+            ### Powered by SambaNova's Llama 3.3 70B Instruct
+            
+            Generate tailored resumes and cover letters using cutting-edge AI technology.
+            """)
+            
+            # Status indicator
+            status = gr.Markdown("✅ **Ready** - Llama 3.3 70B Model Loaded", elem_classes="status-ready")
+            
+            # Main layout - side by side
+            with gr.Row(equal_height=True):
+                # Left column - Inputs  
+                with gr.Column(scale=1):
+                    gr.Markdown("## 📝 Input Information")
+                    
                     self.user_info = gr.Textbox(
-                        label="👤 Your Profile",
-                        placeholder="Paste your education, experience, skills...",
-                        lines=15
+                        label="👤 Your Professional Profile",
+                        placeholder="""Example:
+• Software Engineer with 5+ years experience
+• Expert in Python, React, AWS
+• Led team of 8 developers at TechCorp
+• MBA in Technology Management
+• Passionate about AI and machine learning
+                        
+Paste your complete background here...""",
+                        lines=12,
+                        max_lines=15
                     )
+                    
                     self.job_description = gr.Textbox(
-                        label="📄 Job Description",
-                        placeholder="Paste the full job posting here...",
-                        lines=10
+                        label="📄 Target Job Description",
+                        placeholder="""Paste the complete job posting here:
+- Job title and company
+- Requirements and qualifications  
+- Responsibilities
+- Company culture info
+- Any other relevant details...""",
+                        lines=8,
+                        max_lines=12
                     )
+                    
+                    # Control buttons
                     with gr.Row():
-                        self.generate_btn = gr.Button("🚀 Generate Application")
-                        self.clear_btn = gr.Button("🗑️ Clear")
-
-                with gr.Column():
+                        self.generate_btn = gr.Button(
+                            "🚀 Generate Application", 
+                            variant="primary",
+                            size="lg"
+                        )
+                        self.clear_btn = gr.Button(
+                            "🗑️ Clear All", 
+                            variant="secondary"
+                        )
+                
+                # Right column - Output
+                with gr.Column(scale=1):
+                    gr.Markdown("## 📄 Generated Documents")
+                    
                     self.output = gr.Textbox(
-                        label="📄 Output",
+                        label="🎯 Your Tailored Application Materials",
+                        placeholder="Click 'Generate Application' to create your personalized resume and cover letter...",
                         lines=25,
-                        show_copy_button=True
+                        max_lines=30,
+                        show_copy_button=True,
+                        interactive=False
                     )
-
+            
+            # Progress and tips
+            gr.Markdown("""
+            ### 💡 Tips for Best Results:
+            - **Be specific** about your achievements with numbers/metrics
+            - **Include keywords** from your target industry  
+            - **Paste the complete** job description for better matching
+            - **Review the output** and customize as needed
+            
+            ### 🔄 Processing Steps:
+            1. **Profile Analysis** - Understanding your background
+            2. **Job Research** - Decoding employer requirements  
+            3. **Strategy Development** - Optimizing your positioning
+            4. **Resume Generation** - Creating tailored content
+            5. **Cover Letter Writing** - Personalizing your pitch
+            6. **Quality Assurance** - Ensuring excellence
+            """)
+
+            # Event handlers
+            def process_with_status(user_info, job_desc):
+                try:
+                    result = self.agent.process_application(user_info, job_desc)
+                    return result, "✅ **Complete** - Your application materials are ready!"
+                except Exception as e:
+                    return f"❌ Error: {str(e)}", "❌ **Error** - Please check your API key and try again"
+            
             self.generate_btn.click(
-                fn=self.agent.process_application,
+                fn=lambda: "🔄 **Generating...** SambaNova Llama 3.3 70B is processing your request",
+                outputs=status
+            ).then(
+                fn=process_with_status,
                 inputs=[self.user_info, self.job_description],
-                outputs=self.output
+                outputs=[self.output, status]
+            )
+            
+            self.clear_btn.click(
+                fn=lambda: ("", "", "Click 'Generate Application' to create your personalized resume and cover letter...", "✅ **Ready** - Llama 3.3 70B Model Loaded"),
+                outputs=[self.user_info, self.job_description, self.output, status]
             )
-            self.clear_btn.click(fn=lambda: ("", "", ""), outputs=[self.user_info, self.job_description, self.output])
 
         return demo
 
-    def _css(self):
-        return ".gradio-container { max-width: 1200px !important; margin: auto; }"
+    def _css(self) -> str:
+        """Enhanced CSS for better visual design."""
+        return """
+        .gradio-container { 
+            max-width: 1400px !important; 
+            margin: auto;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        
+        .status-ready {
+            background: linear-gradient(90deg, #10b981, #059669);
+            color: white;
+            padding: 10px;
+            border-radius: 8px;
+            text-align: center;
+            margin: 10px 0;
+        }
+        
+        /* Button styling */
+        .btn-primary {
+            background: linear-gradient(90deg, #3b82f6, #1d4ed8) !important;
+            border: none !important;
+            color: white !important;
+            font-weight: bold !important;
+        }
+        
+        .btn-primary:hover {
+            background: linear-gradient(90deg, #1d4ed8, #1e40af) !important;
+        }
+        
+        /* Enhanced textbox styling */
+        .textbox textarea {
+            border-radius: 8px !important;
+            border: 2px solid #e5e7eb !important;
+        }
+        
+        .textbox textarea:focus {
+            border-color: #3b82f6 !important;
+            box-shadow: 0 0 0 3px rgba(59, 130, 246, 0.1) !important;
+        }
+        
+        /* Column gap */
+        .flex.gap-4 > div {
+            gap: 1.5rem;
+        }
+        """
 
 
 # === Entry Point ===
 
 def main():
+    """Main entry point with enhanced error handling."""
     try:
-        global career_agent
+        print("🚀 Initializing Career Agent with SambaNova...")
+        
+        # Check for API key
+        if not os.getenv("SAMBANOVA_API_KEY"):
+            print("❌ Error: SAMBANOVA_API_KEY environment variable not found!")
+            print("Please set your SambaNova API key:")
+            print("export SAMBANOVA_API_KEY='your-api-key-here'")
+            return
+        
         career_agent = CareerAgent()
+        
+        print("✅ SambaNova Llama 3.3 70B initialized successfully!")
+        
         interface = CareerAgentInterface(career_agent)
         demo = interface.create_interface()
-        demo.launch(server_name="0.0.0.0", server_port=7860)
+        
+        print("🌐 Launching Gradio interface...")
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True
+        )
+        
     except Exception as e:
         logger.error(f"Startup error: {e}")
         print(f"❌ Startup Error: {str(e)}")
+        print("\nTroubleshooting:")
+        print("1. Check your SAMBANOVA_API_KEY is valid")
+        print("2. Ensure you have internet connection")
+        print("3. Verify all dependencies are installed: pip install openai gradio python-dotenv")
 
 
 if __name__ == "__main__":
-    main()
+    main()

requirements.txt

@@ -1,3 +1,5 @@
 gradio
 smolagents
 duckduckgo-search
+openai
+python-dotenv