Update src/app.py

src/app.py

@@ -59,207 +59,228 @@ from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer
 from reportlab.lib.styles import getSampleStyleSheet
 from reportlab.lib.units import inch
 
-# Claude Chatbot Class
-import time
-import os
-import requests
-import json
-import streamlit as st
+import nltk
+from nltk.tokenize import word_tokenize
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+import re
+from datetime import datetime
+from typing import Dict, List
 
-class ClaudeChatbot:
+# Simple NLP processor
+class SimpleNLPProcessor:
     def __init__(self):
-        self.api_key = os.getenv('OPENROUTER_API_KEY')
-        self.base_url = "https://openrouter.ai/api/v1/chat/completions"
-        
-        # Use a reliable free model
-        self.model = "meta-llama/llama-3.2-3b-instruct:free"
-        
-        # More lenient rate limiting
-        self.last_request_time = 0
-        self.min_request_interval = 2  # Reduced to 2 seconds
-        self.daily_requests = 0
-        self.max_daily_requests = 200  # Increased limit
-        
-        # Debug mode
-        self.debug = True
-        
-        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.")
-            if self.debug:
-                st.write("**Debug**: Checked environment variable 'OPENROUTER_API_KEY'")
+        self.setup_nltk()
+        
+    def setup_nltk(self):
+        try:
+            nltk.download('punkt', quiet=True)
+            nltk.download('stopwords', quiet=True)
+            nltk.download('wordnet', quiet=True)
+            self.stop_words = set(stopwords.words('english'))
+            self.lemmatizer = WordNetLemmatizer()
+        except:
+            self.stop_words = {'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'with'}
+            self.lemmatizer = None
     
-    def _wait_for_rate_limit(self):
-        """Ensure we don't exceed rate limits"""
-        current_time = time.time()
-        time_since_last_request = current_time - self.last_request_time
-        
-        if time_since_last_request < self.min_request_interval:
-            sleep_time = self.min_request_interval - time_since_last_request
-            if self.debug:
-                st.info(f"Rate limiting: waiting {sleep_time:.1f} seconds...")
-            time.sleep(sleep_time)
-        
-        self.last_request_time = time.time()
+    def process_text(self, text: str) -> str:
+        """Clean and process text for better context"""
+        try:
+            tokens = word_tokenize(text.lower())
+        except:
+            tokens = text.lower().split()
+        
+        # Remove stopwords and short tokens
+        filtered_tokens = [token for token in tokens 
+                          if token not in self.stop_words and len(token) > 2]
+        
+        # Lemmatize if available
+        if self.lemmatizer:
+            try:
+                filtered_tokens = [self.lemmatizer.lemmatize(token) for token in filtered_tokens]
+            except:
+                pass
+        
+        # Return key terms (limit to avoid long prompts)
+        return ' '.join(filtered_tokens[:15])
+
+# Simple memory management
+class SimpleChatMemory:
+    def __init__(self):
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
     
-    def test_connection(self):
-        """Test the API connection with a simple request"""
-        if not self.api_key:
-            return "Error: No API key found"
-        
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://streamlit-resume-analyzer.com",
-            "X-Title": "AI Resume Analyzer"
+    def add_conversation(self, user_msg: str, bot_response: str):
+        conversation = {
+            'user': user_msg,
+            'bot': bot_response,
+            'timestamp': datetime.now().strftime("%H:%M:%S")
         }
+        st.session_state.chat_history.append(conversation)
         
-        test_data = {
-            "model": self.model,
-            "messages": [
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": "Say 'Connection test successful'"}
-            ],
-            "max_tokens": 50,
-            "temperature": 0.1
-        }
+        # Keep only last 8 conversations to save memory
+        if len(st.session_state.chat_history) > 8:
+            st.session_state.chat_history = st.session_state.chat_history[-8:]
+    
+    def get_recent_context(self, limit: int = 2) -> str:
+        """Get recent conversation context"""
+        if not st.session_state.chat_history:
+            return ""
+        
+        recent = st.session_state.chat_history[-limit:]
+        context_parts = []
+        for conv in recent:
+            context_parts.append(f"User asked: {conv['user'][:50]}...")
         
+        return " | ".join(context_parts) if context_parts else ""
+
+# Main chatbot class
+class SimpleCPUChatbot:
+    def __init__(self):
+        self.model_name = "distilgpt2"  # Fast, CPU-friendly model
+        self.model = None
+        self.tokenizer = None
+        self.pipeline = None
+        self.nlp_processor = SimpleNLPProcessor()
+        self.memory = SimpleChatMemory()
+        self.is_loaded = False
+    
+    @st.cache_resource
+    def load_model(_self):
+        """Load the model (cached for efficiency)"""
         try:
-            response = requests.post(self.base_url, headers=headers, json=test_data, timeout=10)
-            
-            if self.debug:
-                st.write(f"**Debug - Test Response Status**: {response.status_code}")
-                st.write(f"**Debug - Response Headers**: {dict(response.headers)}")
-            
-            if response.status_code == 200:
-                result = response.json()
-                if 'choices' in result and len(result['choices']) > 0:
-                    return f"✅ Connection successful: {result['choices'][0]['message']['content']}"
-                else:
-                    return f"❌ Unexpected response format: {result}"
-            else:
-                error_text = response.text
-                return f"❌ Connection failed ({response.status_code}): {error_text}"
+            with st.spinner("Loading AI model (first time may take 2-3 minutes)..."):
+                # Load tokenizer
+                tokenizer = AutoTokenizer.from_pretrained(_self.model_name)
+                tokenizer.pad_token = tokenizer.eos_token
                 
-        except requests.exceptions.Timeout:
-            return "❌ Connection test timed out"
-        except requests.exceptions.ConnectionError:
-            return "❌ Connection error - check internet connection"
+                # Load model with CPU optimization
+                model = AutoModelForCausalLM.from_pretrained(
+                    _self.model_name,
+                    torch_dtype=torch.float32,  # Use float32 for CPU
+                    low_cpu_mem_usage=True
+                )
+                
+                # Create pipeline
+                text_generator = pipeline(
+                    "text-generation",
+                    model=model,
+                    tokenizer=tokenizer,
+                    device=-1,  # CPU only
+                    max_new_tokens=80,
+                    do_sample=True,
+                    temperature=0.7,
+                    top_p=0.9,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+                
+                return model, tokenizer, text_generator
         except Exception as e:
-            return f"❌ Test failed: {str(e)}"
+            st.error(f"Failed to load model: {str(e)}")
+            return None, None, None
     
-    def generate_response(self, prompt, context="", max_tokens=1000):
-        """Generate response with improved error handling and debugging"""
-        if not self.api_key:
-            return "Error: API key not configured. Please set OPENROUTER_API_KEY in your environment variables."
-        
-        # Check daily limit
-        if self.daily_requests >= self.max_daily_requests:
-            return f"Daily request limit reached ({self.max_daily_requests} requests). Please try again tomorrow."
-        
-        # Rate limiting
-        self._wait_for_rate_limit()
-        
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "HTTP-Referer": "https://streamlit-resume-analyzer.com",
-            "X-Title": "AI Resume Analyzer"
-        }
+    def initialize(self):
+        """Initialize the chatbot"""
+        if not self.is_loaded:
+            result = self.load_model()
+            if result[0] is not None:
+                self.model, self.tokenizer, self.pipeline = result
+                self.is_loaded = True
+                st.success("AI model loaded successfully!")
+                return True
+            else:
+                st.error("Failed to load AI model")
+                return False
+        return True
+    
+    def create_prompt(self, user_input: str, resume_context: str = "") -> str:
+        """Create a focused prompt for resume advice"""
+        # Process user input for key terms
+        key_terms = self.nlp_processor.process_text(user_input)
+        
+        # Get conversation context
+        recent_context = self.memory.get_recent_context()
         
-        system_prompt = """You are an expert resume and career consultant with deep knowledge of hiring practices, ATS systems, and industry requirements. You provide actionable, specific advice to help job seekers improve their resumes and career prospects. Always be encouraging but honest in your feedback. Keep responses concise and focused."""
+        # Build prompt
+        prompt_parts = [
+            "You are a professional resume consultant. Give specific, helpful advice."
+        ]
         
-        if context:
-            # Limit context to avoid token limits
-            system_prompt += f"\n\nContext about the user's resume:\n{context[:1000]}"
+        # Add resume context if available (limited)
+        if resume_context:
+            resume_excerpt = resume_context[:200] + "..." if len(resume_context) > 200 else resume_context
+            prompt_parts.append(f"Resume excerpt: {resume_excerpt}")
         
-        data = {
-            "model": self.model,
-            "messages": [
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": prompt}
-            ],
-            "max_tokens": max_tokens,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "frequency_penalty": 0.1
-        }
+        # Add conversation context
+        if recent_context:
+            prompt_parts.append(f"Previous topics: {recent_context}")
         
-        if self.debug:
-            st.write(f"**Debug - Request URL**: {self.base_url}")
-            st.write(f"**Debug - Model**: {self.model}")
-            st.write(f"**Debug - Prompt length**: {len(prompt)} chars")
-            st.write(f"**Debug - Context length**: {len(context)} chars")
+        # Add key terms from current question
+        if key_terms:
+            prompt_parts.append(f"Focus areas: {key_terms}")
+        
+        # Add the actual question
+        prompt_parts.append(f"Question: {user_input}")
+        prompt_parts.append("Advice:")
+        
+        return " | ".join(prompt_parts)
+    
+    def generate_response(self, user_input: str, resume_context: str = "") -> str:
+        """Generate response using the loaded model"""
+        if not self.is_loaded:
+            return "Please initialize the AI model first by clicking 'Initialize AI'."
         
         try:
-            if self.debug:
-                st.info(f"Making API request... (Daily requests used: {self.daily_requests}/{self.max_daily_requests})")
+            # Create prompt
+            prompt = self.create_prompt(user_input, resume_context)
             
-            response = requests.post(self.base_url, headers=headers, json=data, timeout=30)
+            # Generate response
+            result = self.pipeline(
+                prompt,
+                max_new_tokens=60,  # Keep responses concise
+                num_return_sequences=1,
+                temperature=0.7,
+                do_sample=True,
+                top_p=0.9
+            )
             
-            if self.debug:
-                st.write(f"**Debug - Response Status**: {response.status_code}")
-                st.write(f"**Debug - Response Headers**: {dict(response.headers)}")
+            # Extract and clean response
+            generated_text = result[0]['generated_text']
+            response = generated_text.replace(prompt, "").strip()
             
-            # Handle different error codes with more detail
-            if response.status_code == 429:
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('error', {}).get('message', 'Rate limit exceeded')
-                    return f"Rate limit exceeded: {error_message}. Please wait and try again."
-                except:
-                    return "Rate limit exceeded. Please wait a few minutes and try again."
-                    
-            elif response.status_code == 402:
-                return "This request requires payment. Please add credits to your OpenRouter account."
-                
-            elif response.status_code == 401:
-                return "Invalid API key. Please check your OPENROUTER_API_KEY environment variable."
-                
-            elif response.status_code == 400:
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('error', {}).get('message', 'Bad request')
-                    if self.debug:
-                        st.write(f"**Debug - 400 Error Details**: {error_data}")
-                    return f"Bad request: {error_message}"
-                except:
-                    return f"Bad request. Raw response: {response.text[:200]}"
-                    
-            elif response.status_code != 200:
-                try:
-                    error_data = response.json()
-                    error_message = error_data.get('error', {}).get('message', response.text[:200])
-                    return f"API Error {response.status_code}: {error_message}"
-                except:
-                    return f"API Error {response.status_code}: {response.text[:200]}"
+            # Clean up the response
+            response = self.clean_response(response, user_input)
+            
+            # Add to memory
+            self.memory.add_conversation(user_input, response)
+            
+            return response
             
-            # Success case
-            try:
-                result = response.json()
-                if self.debug:
-                    st.write(f"**Debug - Response keys**: {list(result.keys())}")
-                
-                if 'choices' in result and len(result['choices']) > 0:
-                    self.daily_requests += 1
-                    response_text = result['choices'][0]['message']['content'].strip()
-                    if self.debug:
-                        st.success(f"Response generated successfully! (Remaining: {self.max_daily_requests - self.daily_requests})")
-                    return response_text
-                else:
-                    return f"Error: Unexpected response format. Response keys: {list(result.keys())}"
-            except json.JSONDecodeError as e:
-                return f"Error: Invalid JSON response. Raw response: {response.text[:200]}"
-                
-        except requests.exceptions.Timeout:
-            return "Request timed out after 30 seconds. Please try again with a shorter question."
-        except requests.exceptions.ConnectionError:
-            return "Connection error. Please check your internet connection and try again."
-        except requests.exceptions.RequestException as e:
-            return f"Request error: {str(e)}"
         except Exception as e:
-            return f"Unexpected error: {str(e)}"
-
+            return f"Sorry, I encountered an error: {str(e)}. Please try a simpler question."
+    
+    def clean_response(self, response: str, user_input: str) -> str:
+        """Clean and improve the generated response"""
+        # Remove extra whitespace and newlines
+        response = re.sub(r'\s+', ' ', response).strip()
+        
+        # Split into sentences and take first few good ones
+        sentences = [s.strip() for s in response.split('.') if s.strip()]
+        good_sentences = []
+        
+        for sentence in sentences[:3]:  # Max 3 sentences
+            if len(sentence) > 10 and not sentence.lower().startswith(('you are', 'i am', 'as a')):
+                good_sentences.append(sentence)
+        
+        if good_sentences:
+            response = '. '.join(good_sentences)
+            if not response.endswith('.'):
+                response += '.'
+        else:
+            # Fallback response
+            response = "I'd be happy to help with your resume. Could you be more specific about what you need assistance with?"
+        
+        return response
 # Download NLTK data if not already present
 @st.cache_resource
 def download_nltk_data():
@@ -336,7 +357,7 @@ def basic_grammar_check(text):
 class ResumeAnalyzer:
     def __init__(self):
         self.nlp, self.grammar_tool = init_tools()
-        self.chatbot = ClaudeChatbot()
+        self.chatbot = SimpleCPUChatbot()
         
         try:
             self.stop_words = set(stopwords.words('english'))
@@ -685,6 +706,93 @@ class ResumeAnalyzer:
         buffer.seek(0)
         return buffer
 
+def create_simple_chat_interface(resume_context: str = ""):
+    """Create simple chat interface for the resume analyzer"""
+    
+    st.header("🤖 AI Resume Assistant")
+    
+    # Initialize chatbot
+    if 'simple_chatbot' not in st.session_state:
+        st.session_state.simple_chatbot = SimpleCPUChatbot()
+    
+    chatbot = st.session_state.simple_chatbot
+    
+    # Model initialization
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        st.info("Using DistilGPT2 - Fast CPU-only model (≈250MB download)")
+    
+    with col2:
+        if st.button("Initialize AI", type="primary"):
+            chatbot.initialize()
+    
+    # Chat interface
+    if chatbot.is_loaded:
+        st.success("✅ AI Ready")
+        
+        # Sample questions
+        with st.expander("💡 Try asking"):
+            sample_questions = [
+                "How can I improve my resume?",
+                "What skills should I add?",
+                "How do I make it more ATS-friendly?",
+                "What's wrong with my experience section?"
+            ]
+            for q in sample_questions:
+                if st.button(q, key=f"sample_{hash(q)}"):
+                    st.session_state.current_question = q
+        
+        # Chat input
+        user_question = st.text_input(
+            "Ask about your resume:",
+            value=st.session_state.get('current_question', ''),
+            placeholder="How can I improve my resume for tech jobs?",
+            key="chat_input"
+        )
+        
+        # Send button and clear
+        col1, col2 = st.columns([1, 3])
+        with col1:
+            send_clicked = st.button("Send", type="primary")
+        with col2:
+            if st.button("Clear Chat"):
+                st.session_state.chat_history = []
+                if 'current_question' in st.session_state:
+                    del st.session_state.current_question
+                st.experimental_rerun()
+        
+        # Generate response
+        if send_clicked and user_question.strip():
+            with st.spinner("Thinking..."):
+                response = chatbot.generate_response(user_question, resume_context)
+                if 'current_question' in st.session_state:
+                    del st.session_state.current_question
+                st.experimental_rerun()
+        
+        # Display chat history
+        if st.session_state.chat_history:
+            st.subheader("💬 Conversation")
+            
+            for conv in reversed(st.session_state.chat_history[-5:]):  # Show last 5
+                st.markdown(f"**You:** {conv['user']}")
+                st.markdown(f"**AI:** {conv['bot']}")
+                st.caption(f"Time: {conv['timestamp']}")
+                st.divider()
+    
+    else:
+        st.warning("Click 'Initialize AI' to start chatting")
+        
+        with st.expander("ℹ️ About this AI"):
+            st.markdown("""
+            **Model**: DistilGPT2 (CPU-optimized)
+            **Size**: ~250MB download
+            **Speed**: 2-5 seconds per response
+            **Memory**: ~1GB RAM usage
+            
+            This model runs entirely on your CPU and provides helpful resume advice.
+            First initialization will download the model files.
+            """)
 def main():
     st.set_page_config(
         page_title="AI Resume Analyzer with Chatbot",
@@ -915,87 +1023,8 @@ def main():
                 
                 # Chat Interface
                 st.header("💬 Chat with Resume Assistant")
+                create_simple_chat_interface(st.session_state.get('resume_context', ''))
                 
-                # Show API status
-                if not os.getenv('OPENROUTER_API_KEY'):
-                    st.error("❌ Chat feature unavailable: OPENROUTER_API_KEY not configured")
-                    st.info("Please set your OpenRouter API key in environment variables to use the chat feature.")
-                else:
-                    # Debugging information
-                    with st.expander("🔧 Debug Information", expanded=False):
-                        st.write("**API Key Status:**", "✅ Found" if os.getenv('OPENROUTER_API_KEY') else "❌ Missing")
-                        if os.getenv('OPENROUTER_API_KEY'):
-                            api_key = os.getenv('OPENROUTER_API_KEY')
-                            st.write("**API Key Preview:**", f"{api_key[:10]}...{api_key[-4:]}" if len(api_key) > 14 else "Key too short")
-                        st.write("**Model:**", analyzer.chatbot.model)
-                        st.write("**Rate Limit Interval:**", f"{analyzer.chatbot.min_request_interval} seconds")
-                        st.write("**Daily Requests Used:**", f"{analyzer.chatbot.daily_requests}/{analyzer.chatbot.max_daily_requests}")
-                    
-                    st.info(f"🤖 Using model: {analyzer.chatbot.model}")
-                    st.warning("⚠️ OpenRouter free tier limits: 50 requests/day, 6+ seconds between requests")
-                    
-                    # Test API button
-                    if st.button("🧪 Test API Connection", help="Send a simple test request to verify API is working"):
-                        with st.spinner("Testing API connection..."):
-                            test_response = analyzer.chatbot.generate_response(
-                                "Just say 'API test successful' in exactly those words.",
-                                ""
-                            )
-                            st.write("**Test Response:**", test_response)
-                    
-                    # Chat input
-                    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",
-                        help="Ask specific questions about your resume and get personalized advice"
-                    )
-                    
-                    col1, col2 = st.columns([1, 4])
-                    with col1:
-                        send_button = st.button("Send", type="primary")
-                    with col2:
-                        if st.button("Clear Chat"):
-                            st.session_state.chat_history = []
-                            st.rerun()
-                    
-                    if send_button and user_question.strip():
-                        # Add user message to history
-                        st.session_state.chat_history.append(("user", user_question))
-                        
-                        # Get AI response
-                        with st.spinner("Getting AI response..."):
-                            response = analyzer.chatbot.generate_response(
-                                user_question, 
-                                st.session_state.resume_context
-                            )
-                        
-                        # Add AI response to history
-                        st.session_state.chat_history.append(("assistant", response))
-                        st.rerun()
-                    
-                    # Display chat history
-                    if st.session_state.chat_history:
-                        st.subheader("Chat History")
-                        
-                        # Display messages in reverse order (newest first) with a limit
-                        chat_display_limit = 10  # Show last 10 messages
-                        recent_messages = st.session_state.chat_history[-chat_display_limit:]
-                        
-                        for role, message in reversed(recent_messages):
-                            if role == "user":
-                                st.markdown(f"**👤 You:** {message}")
-                            else:
-                                st.markdown(f"**🤖 Assistant:** {message}")
-                            st.markdown("---")
-                        
-                        if len(st.session_state.chat_history) > chat_display_limit:
-                            st.info(f"Showing {chat_display_limit} most recent messages. Total messages: {len(st.session_state.chat_history)}")
-                
-            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 check the file format and try again.")
     
@@ -1017,31 +1046,9 @@ def main():
             
             **Supported Formats**: PDF, DOCX, TXT
             
-            **Chat Feature**: Set OPENROUTER_API_KEY environment variable to enable AI chat assistance
+            **Chat Feature**: AI chat assistance
             """)
         
-        # API Setup Instructions
-        with st.expander("🔧 Setup Instructions for Chat Feature"):
-            st.markdown("""
-            To enable the AI chat assistant:
-            
-            1. **Get an API key from OpenRouter**:
-               - Visit https://openrouter.ai
-               - Sign up for a free account
-               - Get your API key from the dashboard
-            
-            2. **Set the environment variable**:
-               - Add `OPENROUTER_API_KEY=your_api_key_here` to your environment
-               - For local development, you can use a `.env` file
-               - For deployment, set it in your hosting platform's environment variables
-            
-            3. **Free tier includes**:
-               - Limited requests per hour
-               - Access to free models like Llama 3.2
-               - No credit card required
-            
-            The app will work without the API key, but chat features will be disabled.
-            """)
 
 if __name__ == "__main__":
     main()