Update src/app.py

src/app.py

@@ -60,27 +60,20 @@ from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib.units import inch
 
 # Claude Chatbot Class
-import time
-
 class ClaudeChatbot:
     def __init__(self):
         self.api_key = os.getenv('OPENROUTER_API_KEY')
         self.base_url = "https://openrouter.ai/api/v1/chat/completions"
         
-        # IMPORTANT: Claude Sonnet 4 is NOT free - use a free model instead
-        # Free models on OpenRouter include:
-        self.model = "meta-llama/llama-3.2-3b-instruct:free"  # Free alternative
-        # Other free options:
-        # "microsoft/phi-3-mini-128k-instruct:free"
-        # "huggingface/zephyr-7b-beta:free"
-        # "mistralai/mistral-7b-instruct:free"
+        # Using free models on OpenRouter
+        self.model = "meta-llama/llama-3.2-3b-instruct:free"
         
         if not self.api_key:
             st.error("❌ OPENROUTER_API_KEY not found in environment variables!")
             st.info("Please set your OpenRouter API key in the environment variables.")
     
     def generate_response(self, prompt, context="", max_tokens=1500):
-        """Generate response using free models via OpenRouter"""
+        """Generate response using free models via OpenRouter - No rate limiting"""
         if not self.api_key:
             return "Error: API key not configured"
         
@@ -126,11 +119,7 @@ class ClaudeChatbot:
         try:
             response = requests.post(self.base_url, headers=headers, json=data, timeout=30)
             
-            if response.status_code == 429:
-                st.warning("Rate limit hit. Waiting 60 seconds...")
-                time.sleep(60)
-                response = requests.post(self.base_url, headers=headers, json=data, timeout=30)
-            
+            # Handle payment required error
             if response.status_code == 402:
                 return "Error: This model requires payment. Please switch to a free model or add credits to your OpenRouter account."
             
@@ -146,7 +135,7 @@ class ClaudeChatbot:
             if e.response.status_code == 402:
                 return "Error: Payment required. This model is not free. Please use a free model or add credits."
             elif e.response.status_code == 429:
-                return "Error: Rate limit exceeded. Please try again later."
+                return "Error: Too many requests. Please try again in a moment."
             else:
                 return f"HTTP Error: {e.response.status_code} - {str(e)}"
         except requests.exceptions.RequestException as e:
@@ -283,6 +272,18 @@ class ResumeAnalyzer:
                                 "business process", "gap analysis", "user stories", "workflow", "project management"],
             "Full Stack Developer": ["html", "css", "javascript", "react", "angular", "vue", "node.js", "express",
                                    "mongodb", "postgresql", "rest api", "graphql", "version control", "responsive design"],
+            "Machine Learning Engineer": [
+                "python", "tensorflow", "pytorch", "scikit-learn", "pandas", "numpy", "machine learning",
+                "deep learning", "neural networks", "computer vision", "nlp", "data science", "algorithms",
+                "statistics", "linear algebra", "calculus", "regression", "classification", "clustering",
+                "feature engineering", "model deployment", "mlops", "docker", "kubernetes", "aws", "gcp"
+            ],
+            "AI Engineer": [
+                "artificial intelligence", "machine learning", "deep learning", "neural networks", "python",
+                "tensorflow", "pytorch", "computer vision", "nlp", "natural language processing", "opencv",
+                "transformers", "bert", "gpt", "reinforcement learning", "generative ai", "llm", "chatbot",
+                "model optimization", "ai ethics", "edge ai", "quantization", "onnx", "tensorrt"
+            ]
         }
         
         # Common skills database
@@ -630,19 +631,6 @@ def main():
     # Initialize analyzer
     try:
         analyzer = ResumeAnalyzer()
-        # Add ML/AI Engineer to job keywords
-        analyzer.job_keywords["Machine Learning Engineer"] = [
-            "python", "tensorflow", "pytorch", "scikit-learn", "pandas", "numpy", "machine learning",
-            "deep learning", "neural networks", "computer vision", "nlp", "data science", "algorithms",
-            "statistics", "linear algebra", "calculus", "regression", "classification", "clustering",
-            "feature engineering", "model deployment", "mlops", "docker", "kubernetes", "aws", "gcp"
-        ]
-        analyzer.job_keywords["AI Engineer"] = [
-            "artificial intelligence", "machine learning", "deep learning", "neural networks", "python",
-            "tensorflow", "pytorch", "computer vision", "nlp", "natural language processing", "opencv",
-            "transformers", "bert", "gpt", "reinforcement learning", "generative ai", "llm", "chatbot",
-            "model optimization", "ai ethics", "edge ai", "quantization", "onnx", "tensorrt"
-        ]
     except Exception as e:
         st.error(f"Error initializing analyzer: {str(e)}")
         return
@@ -652,15 +640,15 @@ def main():
     job_roles = list(analyzer.job_keywords.keys())
     selected_role = st.sidebar.selectbox("Select Target Job Role:", job_roles)
     
-    # Initialize session state for chat - FIXED
+    # Initialize session state for chat
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = []
     if "resume_context" not in st.session_state:
         st.session_state.resume_context = ""
     if "show_chat" not in st.session_state:
         st.session_state.show_chat = False
-    if "chat_processed" not in st.session_state:
-        st.session_state.chat_processed = False
+    if "waiting_for_response" not in st.session_state:
+        st.session_state.waiting_for_response = False
     
     # File upload section
     st.header("📁 Upload Your Resume")
@@ -723,29 +711,20 @@ def main():
                     with col2:
                         # Generate persona summary
                         persona_summary = analyzer.generate_persona_summary(text, sections)
-                        st.subheader("🎭 AI Persona Summary")
-                        st.info(persona_summary)
-                    
-                    # Word cloud
-                    st.subheader("☁️ Word Cloud")
-                    preprocessed_tokens = analyzer.preprocess_text(text)
-                    if preprocessed_tokens:
-                        wordcloud_text = ' '.join(preprocessed_tokens)
-                        try:
-                            wordcloud = WordCloud(width=800, height=400, background_color='white').generate(wordcloud_text)
-                            
-                            fig, ax = plt.subplots(figsize=(12, 6))
-                            ax.imshow(wordcloud, interpolation='bilinear')
-                            ax.axis('off')
-                            st.pyplot(fig)
-                        except Exception as e:
-                            st.warning("Could not generate word cloud. Showing top words instead.")
-                            word_freq = Counter(preprocessed_tokens)
-                            top_words = word_freq.most_common(20)
-                            
-                            words_df = pd.DataFrame(top_words, columns=['Word', 'Frequency'])
-                            fig = px.bar(words_df, x='Word', y='Frequency', title='Top 20 Words')
-                            st.plotly_chart(fig)
+                        st.subheader("AI-Generated Persona")
+                        st.write(persona_summary)
+                        
+                        # Overall scores
+                        overall_score = (ats_score + match_percentage) / 2
+                        st.metric("Overall Score", f"{overall_score:.1f}/100")
+                        
+                        # Score interpretation
+                        if overall_score >= 80:
+                            st.success("🎉 Excellent! Your resume is well-optimized.")
+                        elif overall_score >= 60:
+                            st.warning("⚠️ Good, but there's room for improvement.")
+                        else:
+                            st.error("❌ Needs significant improvement.")
                 
                 with tab2:
                     st.header("Skills Analysis")
@@ -753,100 +732,70 @@ def main():
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.subheader("🔧 Technical Skills")
+                        st.subheader("Technical Skills Found")
                         if tech_skills:
-                            skills_text = " • ".join(tech_skills)
-                            st.success(f"Found {len(tech_skills)} technical skills:")
-                            st.write(skills_text)
-                            
-                            if len(tech_skills) > 5:
-                                skills_df = pd.DataFrame({
-                                    'Skill': tech_skills[:10],
-                                    'Count': [1] * len(tech_skills[:10])
-                                })
-                                fig = px.pie(skills_df, values='Count', names='Skill', 
-                                           title='Technical Skills Distribution')
-                                st.plotly_chart(fig, use_container_width=True)
-                            else:
-                                skills_df = pd.DataFrame({
-                                    'Skill': tech_skills,
-                                    'Count': [1] * len(tech_skills)
-                                })
-                                fig = px.bar(skills_df, x='Skill', y='Count', 
-                                           title='Technical Skills Found')
-                                fig.update_xaxis(tickangle=45)
-                                st.plotly_chart(fig, use_container_width=True)
+                            for skill in tech_skills:
+                                st.write(f"✅ {skill}")
                         else:
-                            st.warning("No technical skills detected")
-                            st.info("💡 Consider adding technical skills relevant to your field")
+                            st.write("No technical skills detected. Consider adding relevant technical skills.")
                     
                     with col2:
-                        st.subheader("🤝 Soft Skills")
+                        st.subheader("Soft Skills Found")
                         if soft_skills:
-                            skills_text = " • ".join(soft_skills)
-                            st.success(f"Found {len(soft_skills)} soft skills:")
-                            st.write(skills_text)
-                            
-                            if len(soft_skills) > 3:
-                                soft_df = pd.DataFrame({
-                                    'Skill': soft_skills[:8],
-                                    'Count': [1] * len(soft_skills[:8])
-                                })
-                                fig = px.bar(soft_df, x='Skill', y='Count', 
-                                           title='Soft Skills Found',
-                                           color='Skill')
-                                fig.update_xaxis(tickangle=45)
-                                st.plotly_chart(fig, use_container_width=True)
+                            for skill in soft_skills:
+                                st.write(f"✅ {skill}")
                         else:
-                            st.warning("No soft skills detected")
-                            st.info("💡 Consider highlighting soft skills like leadership, communication, teamwork")
+                            st.write("No soft skills detected. Consider highlighting your interpersonal abilities.")
                     
                     # Role-specific keyword analysis
-                    st.subheader(f"🎯 {selected_role} Keywords")
-                    if found_keywords:
-                        st.success(f"Found {len(found_keywords)} relevant keywords for {selected_role}:")
-                        keywords_text = " • ".join(found_keywords)
-                        st.write(keywords_text)
-                        st.info(f"Match Percentage: {match_percentage:.1f}%")
+                    st.subheader(f"Keywords for {selected_role}")
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric("Match Percentage", f"{match_percentage:.1f}%")
                         
-                        # Progress bar for match percentage
-                        st.progress(match_percentage / 100)
-                    else:
-                        st.warning(f"No {selected_role}-specific keywords found")
-                        missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] if kw not in text.lower()]
-                        if missing_keywords:
-                            st.info(f"💡 Consider adding these keywords: {', '.join(missing_keywords[:5])}")
+                        if match_percentage >= 70:
+                            st.success("🎯 Great keyword match!")
+                        elif match_percentage >= 50:
+                            st.warning("⚠️ Moderate keyword match")
+                        else:
+                            st.error("❌ Low keyword match")
+                    
+                    with col2:
+                        st.write("**Found Keywords:**")
+                        if found_keywords:
+                            for keyword in found_keywords:
+                                st.write(f"✅ {keyword}")
+                        else:
+                            st.write("No role-specific keywords found.")
+                    
+                    # Missing keywords
+                    missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] 
+                                      if kw not in found_keywords]
+                    if missing_keywords:
+                        st.subheader("Suggested Keywords to Add")
+                        for keyword in missing_keywords[:10]:  # Show top 10
+                            st.write(f"➕ {keyword}")
                 
                 with tab3:
                     st.header("Section Breakdown")
                     
                     for section_name, section_content in sections.items():
                         if section_content:
-                            with st.expander(f"📑 {section_name.title()} Section"):
-                                st.text_area(
-                                    f"{section_name.title()} Content",
-                                    section_content,
-                                    height=200,
-                                    key=f"section_{section_name}"
-                                )
-                                
-                                # Section-specific analysis
-                                word_count = len(section_content.split())
-                                st.metric(f"{section_name.title()} Word Count", word_count)
-                                
-                                if section_name == "experience":
-                                    # Analyze experience section
-                                    years_mentioned = len(re.findall(r'\b(19|20)\d{2}\b', section_content))
-                                    companies_mentioned = len(re.findall(r'\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b', section_content))
-                                    st.metric("Years/Dates Mentioned", years_mentioned)
-                                    st.metric("Potential Companies", companies_mentioned)
-                                
-                                elif section_name == "education":
-                                    # Analyze education section
-                                    degrees = re.findall(r'\b(bachelor|master|phd|degree|diploma|certificate)\b', section_content.lower())
-                                    st.metric("Degrees/Certificates Found", len(degrees))
+                            with st.expander(f"📋 {section_name.title()} Section"):
+                                st.write(section_content)
                         else:
                             st.warning(f"⚠️ {section_name.title()} section not found or empty")
+                    
+                    # Section recommendations
+                    st.subheader("Section Recommendations")
+                    missing_sections = [name for name, content in sections.items() if not content]
+                    if missing_sections:
+                        st.write("**Missing or Empty Sections:**")
+                        for section in missing_sections:
+                            st.write(f"❌ {section.title()}")
+                    else:
+                        st.success("✅ All major sections are present!")
                 
                 with tab4:
                     st.header("ATS Analysis")
@@ -854,106 +803,60 @@ def main():
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.subheader("📊 ATS Score Breakdown")
-                        st.metric("Overall ATS Score", f"{ats_score}/100")
+                        st.metric("ATS Score", f"{ats_score}/100")
                         
-                        # ATS score visualization
-                        fig = go.Figure(go.Indicator(
-                            mode = "gauge+number+delta",
-                            value = ats_score,
-                            domain = {'x': [0, 1], 'y': [0, 1]},
-                            title = {'text': "ATS Score"},
-                            delta = {'reference': 70},
-                            gauge = {
-                                'axis': {'range': [None, 100]},
-                                'bar': {'color': "darkblue"},
-                                'steps': [
-                                    {'range': [0, 50], 'color': "lightgray"},
-                                    {'range': [50, 70], 'color': "yellow"},
-                                    {'range': [70, 100], 'color': "green"}
-                                ],
-                                'threshold': {
-                                    'line': {'color': "red", 'width': 4},
-                                    'thickness': 0.75,
-                                    'value': 90
-                                }
-                            }
-                        ))
-                        st.plotly_chart(fig, use_container_width=True)
+                        # ATS Score interpretation
+                        if ats_score >= 80:
+                            st.success("🤖 Excellent ATS compatibility!")
+                        elif ats_score >= 60:
+                            st.warning("⚠️ Good ATS compatibility")
+                        else:
+                            st.error("❌ Poor ATS compatibility")
                     
                     with col2:
-                        st.subheader("🎯 Role Match Analysis")
-                        st.metric("Role Match Score", f"{match_percentage:.1f}%")
-                        
-                        # Combined score
-                        combined_score = (ats_score + match_percentage) / 2
-                        st.metric("Combined Score", f"{combined_score:.1f}/100")
+                        # Grammar check
+                        st.subheader("Grammar Check")
+                        grammar_issues = analyzer.grammar_check(text)
                         
-                        # Score interpretation
-                        if combined_score >= 80:
-                            st.success("🎉 Excellent! Your resume is well-optimized")
-                        elif combined_score >= 60:
-                            st.warning("👍 Good, but room for improvement")
+                        if len(grammar_issues) == 0:
+                            st.success("✅ No grammar issues detected!")
                         else:
-                            st.error("⚠️ Needs significant improvement")
+                            st.warning(f"⚠️ {len(grammar_issues)} potential issues found")
+                            with st.expander("View Grammar Issues"):
+                                for issue in grammar_issues[:10]:  # Show first 10
+                                    st.write(f"• {issue.message}")
                     
-                    # Grammar check
-                    st.subheader("📝 Grammar & Language Quality")
-                    with st.spinner("Checking grammar..."):
-                        grammar_issues = analyzer.grammar_check(text)
+                    # ATS Tips
+                    st.subheader("ATS Optimization Tips")
+                    ats_tips = [
+                        "Use standard section headings (Experience, Education, Skills)",
+                        "Include relevant keywords naturally throughout your resume",
+                        "Use bullet points for easy scanning",
+                        "Avoid images, tables, and complex formatting",
+                        "Use standard fonts (Arial, Calibri, Times New Roman)",
+                        "Save as PDF to preserve formatting",
+                        "Include contact information at the top"
+                    ]
                     
-                    if grammar_issues:
-                        st.warning(f"Found {len(grammar_issues)} potential grammar issues:")
-                        for i, issue in enumerate(grammar_issues[:10]):  # Show first 10 issues
-                            if hasattr(issue, 'message'):
-                                st.write(f"• {issue.message}")
-                            else:
-                                st.write(f"• {str(issue)}")
-                        
-                        if len(grammar_issues) > 10:
-                            st.info(f"... and {len(grammar_issues) - 10} more issues")
-                    else:
-                        st.success("✅ No major grammar issues detected!")
+                    for tip in ats_tips:
+                        st.write(f"💡 {tip}")
                 
                 with tab5:
-                    st.header("Report & Suggestions")
+                    st.header("Comprehensive Analysis & Suggestions")
                     
-                    # Get AI analysis from Claude
+                    # Get Claude analysis if API is available
                     if os.getenv('OPENROUTER_API_KEY'):
-                        st.subheader("🤖 AI-Powered Analysis")
-                        with st.spinner("Getting AI analysis from Claude..."):
+                        with st.spinner("Getting AI-powered analysis..."):
                             claude_analysis = analyzer.get_claude_analysis(
                                 text, sections, selected_role, ats_score, match_percentage
                             )
-                        st.markdown(claude_analysis)
+                        
+                        st.subheader("🤖 AI-Powered Analysis")
+                        st.write(claude_analysis)
                     else:
-                        st.info("Claude API not available. Showing basic recommendations.")
-                    
-                    # Basic recommendations
-                    st.subheader("📋 Quick Recommendations")
-                    recommendations = []
+                        st.warning("⚠️ AI analysis not available. Please set OPENROUTER_API_KEY.")
                     
-                    if ats_score < 70:
-                        recommendations.append("🔹 Improve ATS compatibility by adding more bullet points and clear section headers")
-                    
-                    if match_percentage < 60:
-                        recommendations.append(f"🔹 Add more {selected_role}-specific keywords to improve role match")
-                    
-                    if len(tech_skills) < 5:
-                        recommendations.append("🔹 Include more technical skills relevant to your field")
-                    
-                    if not sections.get('projects'):
-                        recommendations.append("🔹 Consider adding a projects section to showcase your work")
-                    
-                    if len(text.split()) < 300:
-                        recommendations.append("🔹 Expand your resume content - it seems too brief")
-                    elif len(text.split()) > 800:
-                        recommendations.append("🔹 Consider condensing your resume - it might be too lengthy")
-                    
-                    for rec in recommendations:
-                        st.markdown(rec)
-                    
-                    # PDF Report Generation
+                    # Generate PDF report
                     st.subheader("📄 Download Report")
                     if st.button("Generate PDF Report"):
                         try:
@@ -964,135 +867,114 @@ def main():
                             
                             st.download_button(
                                 label="📥 Download PDF Report",
-                                data=pdf_buffer,
+                                data=pdf_buffer.getvalue(),
                                 file_name=f"resume_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
                                 mime="application/pdf"
                             )
                         except Exception as e:
                             st.error(f"Error generating PDF: {str(e)}")
+                    
+                    # Manual recommendations
+                    st.subheader("📝 Quick Recommendations")
+                    recommendations = []
+                    
+                    if ats_score < 70:
+                        recommendations.extend([
+                            "Add more bullet points to improve readability",
+                            "Ensure contact information is clearly visible",
+                            "Use standard section headings"
+                        ])
+                    
+                    if match_percentage < 60:
+                        recommendations.append(f"Include more {selected_role}-specific keywords")
+                    
+                    if not tech_skills:
+                        recommendations.append("Add a dedicated technical skills section")
+                    
+                    if not sections.get('projects'):
+                        recommendations.append("Consider adding a projects section")
+                    
+                    for i, rec in enumerate(recommendations, 1):
+                        st.write(f"{i}. {rec}")
                 
-                # AI Assistant Chat Section (Outside of tabs) - COMPLETELY FIXED
-                st.markdown("---")
-                st.header("🤖 AI Assistant Chat")
+                # Chat Interface
+                st.header("💬 Chat with Resume Assistant")
                 
                 # Toggle chat visibility
-                chat_toggle = st.button("💬 Toggle AI Assistant Chat", key="main_chat_toggle")
-                if chat_toggle:
+                if st.button("🤖 Ask Questions About Your Resume"):
                     st.session_state.show_chat = not st.session_state.show_chat
                 
                 if st.session_state.show_chat:
-                    if not os.getenv('OPENROUTER_API_KEY'):
-                        st.error("Claude API key not configured. Please set OPENROUTER_API_KEY environment variable.")
-                    else:
-                        # Create analysis context for better responses
-                        analysis_context = f"""
-                        Resume Analysis Results:
-                        - Target Role: {selected_role}
-                        - ATS Score: {ats_score}/100
-                        - Role Match: {match_percentage:.1f}%
-                        - Word Count: {len(text.split())}
-                        - Technical Skills Found: {', '.join(tech_skills) if tech_skills else 'None detected'}
-                        - Soft Skills Found: {', '.join(soft_skills) if soft_skills else 'None detected'}
-                        - Keywords Found: {', '.join(found_keywords) if found_keywords else 'None detected'}
-                        - Sections Present: {', '.join([k for k, v in sections.items() if v])}
-                        """
-                        
-                        # Display chat history
-                        for chat in st.session_state.chat_history:
-                            with st.chat_message(chat["role"]):
-                                st.markdown(chat["content"])
-                        
-                        # Suggested questions
-                        st.subheader("💡 Suggested Questions")
-                        col1, col2, col3, col4 = st.columns(4)
-                        
-                        with col1:
-                            if st.button("How can I improve my resume?", key="improve_btn"):
-                                prompt = "Based on my resume analysis, how can I improve my resume to get better ATS scores and job match rates?"
-                                with st.chat_message("user"):
-                                    st.markdown(prompt)
-                                st.session_state.chat_history.append({"role": "user", "content": prompt})
-                                
-                                with st.chat_message("assistant"):
-                                    with st.spinner("Analyzing your resume..."):
-                                        response = analyzer.chatbot.generate_response(prompt, analysis_context + st.session_state.resume_context)
-                                    st.markdown(response)
-                                st.session_state.chat_history.append({"role": "assistant", "content": response})
-                        
-                        with col2:
-                            if st.button("What skills should I add?", key="skills_btn"):
-                                prompt = f"What specific technical and soft skills should I add to my resume for a {selected_role} position based on my current analysis?"
-                                with st.chat_message("user"):
-                                    st.markdown(prompt)
-                                st.session_state.chat_history.append({"role": "user", "content": prompt})
-                                
-                                with st.chat_message("assistant"):
-                                    with st.spinner("Analyzing skill gaps..."):
-                                        response = analyzer.chatbot.generate_response(prompt, analysis_context + st.session_state.resume_context)
-                                    st.markdown(response)
-                                st.session_state.chat_history.append({"role": "assistant", "content": response})
-                        
-                        with col3:
-                            if st.button("Format suggestions?", key="format_btn"):
-                                prompt = "What formatting improvements can I make to my resume to make it more ATS-friendly and visually appealing?"
-                                with st.chat_message("user"):
-                                    st.markdown(prompt)
-                                st.session_state.chat_history.append({"role": "user", "content": prompt})
-                                
-                                with st.chat_message("assistant"):
-                                    with st.spinner("Analyzing format..."):
-                                        response = analyzer.chatbot.generate_response(prompt, analysis_context + st.session_state.resume_context)
-                                    st.markdown(response)
-                                st.session_state.chat_history.append({"role": "assistant", "content": response})
-                        
-                        with col4:
-                            if st.button("🗑️ Clear Chat", key="clear_btn"):
-                                st.session_state.chat_history = []
-                                st.rerun()
-                        
-                        # Chat input - MAIN FIX: Handle chat without multiple responses
-                        user_prompt = st.chat_input("Ask me anything about your resume...")
+                    # Model selection
+                    available_models = analyzer.chatbot.get_available_free_models()
+                    selected_model = st.selectbox(
+                        "Choose AI Model:", 
+                        available_models,
+                        index=0 if analyzer.chatbot.model in available_models else 0
+                    )
+                    
+                    if selected_model != analyzer.chatbot.model:
+                        analyzer.chatbot.switch_model(selected_model)
+                    
+                    # Chat input
+                    if not st.session_state.waiting_for_response:
+                        user_question = st.text_input(
+                            "Ask about your resume:", 
+                            placeholder="e.g., How can I improve my resume for a data scientist role?",
+                            key="chat_input"
+                        )
                         
-                        if user_prompt and user_prompt.strip():
-                            # Display user message
-                            with st.chat_message("user"):
-                                st.markdown(user_prompt)
-                            st.session_state.chat_history.append({"role": "user", "content": user_prompt})
+                        if st.button("Send") and user_question:
+                            st.session_state.waiting_for_response = True
+                            st.session_state.chat_history.append(("user", user_question))
                             
-                            # Generate and display assistant response
-                            with st.chat_message("assistant"):
-                                with st.spinner("Thinking..."):
-                                    response = analyzer.chatbot.generate_response(
-                                        user_prompt, 
-                                        analysis_context + st.session_state.resume_context
-                                    )
-                                st.markdown(response)
-                            st.session_state.chat_history.append({"role": "assistant", "content": response})
-            
+                            with st.spinner("Getting AI response..."):
+                                response = analyzer.chatbot.generate_response(
+                                    user_question, 
+                                    st.session_state.resume_context
+                                )
+                            
+                            st.session_state.chat_history.append(("assistant", response))
+                            st.session_state.waiting_for_response = False
+                            st.rerun()
+                    
+                    # Display chat history
+                    if st.session_state.chat_history:
+                        st.subheader("Chat History")
+                        for role, message in st.session_state.chat_history[-6:]:  # Show last 6 messages
+                            if role == "user":
+                                st.write(f"**You:** {message}")
+                            else:
+                                st.write(f"**Assistant:** {message}")
+                        
+                        if st.button("Clear Chat History"):
+                            st.session_state.chat_history = []
+                            st.rerun()
+                
             except Exception as e:
                 st.error(f"Error during analysis: {str(e)}")
+                st.error("Please check your resume format and try again.")
+        
         else:
-            st.error("Could not extract text from the uploaded file. Please try a different file.")
-    
-    # Footer
-    st.markdown("---")
-    st.markdown("### 📝 Tips for Better Resume Analysis")
-    st.markdown("""
-    - **Upload clear, well-formatted documents** for better text extraction
-    - **Select the appropriate job role** to get relevant keyword matching
-    - **Use the AI Assistant** to get personalized advice
-    - **Download the PDF report** for offline reference
-    - **Check multiple job roles** to see how your resume performs across different positions
-    """)
+            st.error("❌ Could not extract text from the uploaded file. Please check the file format and try again.")
     
-    # Instructions for API setup
-    if not os.getenv('OPENROUTER_API_KEY'):
-        with st.expander("🔧 Setup Instructions for Claude AI"):
+    else:
+        # Show instructions when no file is uploaded
+        st.info("👆 Please upload your resume to get started!")
+        
+        # Show sample analysis
+        with st.expander("📖 What you'll get:", expanded=True):
             st.markdown("""
-            To enable the AI Assistant feature:
-            1. Get an API key from [OpenRouter](https://openrouter.ai/)
-            2. Set the environment variable: `OPENROUTER_API_KEY=your_key_here`
-            3. Restart the application
+            **Our AI-powered resume analyzer provides:**
+            
+            - **📊 Comprehensive Scoring**: ATS compatibility and role-specific matching scores
+            - **🎯 Skills Analysis**: Technical and soft skills identification
+            - **📝 Section Breakdown**: Detailed analysis of each resume section
+            - **🔍 ATS Optimization**: Tips to improve applicant tracking system compatibility
+            - **🤖 AI Chat Assistant**: Ask questions and get personalized advice
+            - **📄 PDF Report**: Downloadable analysis report
+            
+            **Supported Formats**: PDF, DOCX, TXT
             """)
 
 if __name__ == "__main__":