Update self_learning_bot.py

self_learning_bot.py

@@ -3,324 +3,463 @@ import os
 import random
 import re
 import numpy as np
-from datetime import datetime
-from collections import deque, Counter
+from datetime import datetime, date
+import math
 import hashlib
+import requests
+from collections import deque
+import time
+from typing import Dict, List, Any, Tuple
+import markdown
+from bs4 import BeautifulSoup
 
-class UnrestrictedChatbot:
-    def __init__(self, state_file="/tmp/chatbot_state.json"):
+class EnhancedLearningBot:
+    def __init__(self, state_file="/tmp/chatbot_enhanced_state.json"):
         self.state_file = state_file
-        self.conversation_memory = deque(maxlen=50)
+        self.conversation_memory = deque(maxlen=200)
         self.learned_patterns = {}
         self.response_memory = {}
-        self.reward_history = deque(maxlen=100)
+        self.reward_history = deque(maxlen=300)
+        self.web_search_cache = {}
         
-        # Learning parameters
-        self.learning_rate = 0.3
-        self.exploration_rate = 0.2  # Try new responses sometimes
-        self.min_confidence = 0.6
+        # Enhanced learning parameters
+        self.learning_rate = 0.4
+        self.exploration_rate = 0.15
+        self.min_confidence = 0.5
         
-        # Load previous state
+        # Web search configuration
+        self.search_enabled = True
+        self.search_timeout = 10
+        self.max_context_length = 6000
+        
+        # Load existing state
         self.load_state()
         
-        # Initial knowledge base - this will grow through learning
-        self.knowledge_base = {
-            "greetings": {
-                "hello": ["Hey! What would you like to talk about today?", "Hello! Ready for our conversation?", "Hi there! What's on your mind?"],
-                "hi": ["Hi! What shall we discuss?", "Hello! I'm here to learn from you.", "Hey! Ready to chat?"]
-            },
-            "questions": {
-                "how are you": ["I'm learning and improving with each chat! How are you?", "Getting smarter thanks to our conversations! How about you?"],
-                "what can you do": ["I can chat about anything, and I learn from our conversations to get better!"]
-            }
+        # Core knowledge that can be enhanced with web search
+        self.factual_knowledge = {
+            "time": self._get_current_time,
+            "date": self._get_current_date,
+            "day": self._get_current_day,
+            "year": lambda: f"The current year is {datetime.now().year}",
+            "name": "I'm Phoenix AI, your web-enhanced learning assistant!",
+            "capabilities": self._get_capabilities_description
         }
         
-        # Response templates that will evolve
-        self.response_templates = [
-            "That's interesting. Tell me more about {topic}.",
-            "I see. What are your thoughts on {topic}?",
-            "Regarding {topic}, I find that fascinating. Could you elaborate?",
-            "I understand about {topic}. What's your perspective?",
-            "That reminds me of our previous chat about {related_topic}. What do you think?"
-        ]
+        print(f"Enhanced bot initialized with {len(self.learned_patterns)} learned patterns")
 
-    def chat(self, user_input: str) -> str:
-        """Main chat method with real learning"""
+    def chat(self, user_input: str, use_web_search: bool = True, conversation_history: list = None) -> Tuple[str, dict]:
+        """Enhanced chat with web search capability"""
         user_input = user_input.lower().strip()
+        search_context = {}
+        
+        # First, try factual responses
+        factual_response = self._get_factual_response(user_input)
+        if factual_response:
+            self._store_interaction(user_input, factual_response, 0.8, search_context)
+            return factual_response, search_context
+        
+        # Try web search for current information
+        if use_web_search and self._requires_web_search(user_input):
+            search_context = self._perform_web_search(user_input)
+            if search_context.get('content'):
+                web_response = self._generate_web_informed_response(user_input, search_context)
+                self._store_interaction(user_input, web_response, 0.7, search_context)
+                return web_response, search_context
+        
+        # Use learned patterns and memory
+        return self._get_learned_response(user_input, conversation_history), search_context
+
+    def _requires_web_search(self, user_input: str) -> bool:
+        """Determine if query needs web search"""
+        # Questions about current events, recent information, or complex topics
+        current_indicators = [
+            'current', 'recent', 'latest', 'today\'s', 'new', 'update', 'breaking',
+            'news', '2025', '2024', 'now', 'what happened', 'when did', 
+            'how to', 'tutorial', 'guide', 'explain'
+        ]
         
-        # Analyze input
-        context = self._analyze_input(user_input)
-        
-        # Generate candidate responses
-        candidates = self._generate_response_candidates(user_input, context)
-        
-        # Select best response based on learning
-        best_response = self._select_best_response(user_input, candidates, context)
-        
-        # Store interaction for learning
-        interaction = {
-            'input': user_input,
-            'response': best_response,
-            'context': context,
-            'timestamp': datetime.now().isoformat(),
-            'reward': 0.0,  # Will be updated with feedback
-            'confidence': self._calculate_confidence(user_input, best_response)
-        }
+        if any(indicator in user_input for indicator in current_indicators):
+            return True
         
-        self.conversation_memory.append(interaction)
+        # Complex questions that might need updated information
+        if any(word in user_input for word in ['best', 'top', 'review', 'compare', 'versus']):
+            return True
+            
+        return False
+
+    def _perform_web_search(self, query: str) -> dict:
+        """Perform web search using open-source alternatives"""
+        try:
+            # Method 1: Use SearXNG (open-source metasearch engine)
+            search_results = self._search_searxng(query)
+            
+            # Method 2: Fallback to DuckDuckGo or other open APIs
+            if not search_results.get('results'):
+                search_results = self._search_duckduckgo(query)
+            
+            # Process and extract content from top results
+            processed_content = self._process_search_results(search_results, query)
+            return processed_content
+            
+        except Exception as e:
+            print(f"Web search error: {e}")
+            return {'content': '', 'sources': [], 'error': str(e)}
+
+    def _search_searxng(self, query: str) -> dict:
+        """Search using SearXNG instances"""
+        # Public SearXNG instances (rotating for reliability)
+        instances = [
+            "https://searx.be/search?q={query}&format=json",
+            "https://search.unlocked.link/search?q={query}&format=json",
+            "https://searx.space/search?q={query}&format=json"
+        ]
         
-        # Auto-save periodically
-        if len(self.conversation_memory) % 5 == 0:
-            self.save_state()
+        for instance in instances:
+            try:
+                url = instance.format(query=query.replace(' ', '+'))
+                response = requests.get(url, timeout=self.search_timeout)
+                if response.status_code == 200:
+                    data = response.json()
+                    return {
+                        'results': data.get('results', [])[:3],  # Top 3 results
+                        'instance': instance
+                    }
+            except:
+                continue
+        
+        return {'results': []}
+
+    def _search_duckduckgo(self, query: str) -> dict:
+        """Fallback to DuckDuckGo HTML scraping"""
+        try:
+            url = f"https://html.duckduckgo.com/html/?q={query.replace(' ', '+')}"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            response = requests.get(url, headers=headers, timeout=self.search_timeout)
             
-        return best_response
+            # Simple HTML parsing for results
+            soup = BeautifulSoup(response.text, 'html.parser')
+            results = []
+            
+            for result in soup.find_all('.result', limit=3):
+                title_elem = result.find('.result__title')
+                link_elem = result.find('.result__url')
+                snippet_elem = result.find('.result__snippet')
+                
+                if title_elem and link_elem:
+                    results.append({
+                        'title': title_elem.get_text().strip(),
+                        'url': link_elem.get_text().strip(),
+                        'snippet': snippet_elem.get_text().strip() if snippet_elem else ''
+                    })
+            
+            return {'results': results}
+        except Exception as e:
+            print(f"DuckDuckGo search error: {e}")
+            return {'results': []}
 
-    def _analyze_input(self, text: str) -> dict:
-        """Deep analysis of user input"""
-        words = text.split()
-        topics = self._extract_topics(text)
+    def _process_search_results(self, search_results: dict, original_query: str) -> dict:
+        """Process and extract useful content from search results"""
+        content_parts = []
+        sources = []
+        
+        for i, result in enumerate(search_results.get('results', [])[:2]):  # Process top 2 results
+            try:
+                # Extract basic information
+                title = result.get('title', '')
+                url = result.get('url', '')
+                snippet = result.get('snippet', '')
+                
+                # Create content chunk
+                content_chunk = f"Source {i+1}: {title}. {snippet}"
+                content_parts.append(content_chunk)
+                sources.append({'title': title, 'url': url})
+                
+            except Exception as e:
+                print(f"Error processing result {i}: {e}")
+                continue
+        
+        # Combine all content
+        full_content = " ".join(content_parts)[:self.max_context_length]
         
         return {
-            'words': words,
-            'topics': topics,
-            'length': len(words),
-            'has_question': '?' in text,
-            'sentiment': self._analyze_sentiment(text),
-            'similar_patterns': self._find_similar_patterns(text),
-            'input_hash': hashlib.md5(text.encode()).hexdigest()[:8]
+            'content': full_content,
+            'sources': sources,
+            'original_query': original_query,
+            'result_count': len(sources)
         }
 
-    def _extract_topics(self, text: str) -> list:
-        """Extract main topics from text"""
-        topics = []
-        topic_keywords = {
-            'technology': ['computer', 'tech', 'software', 'ai', 'program', 'code', 'internet'],
-            'relationships': ['friend', 'family', 'love', 'partner', 'relationship', 'dating'],
-            'work': ['job', 'work', 'career', 'boss', 'office', 'colleague'],
-            'hobbies': ['game', 'movie', 'music', 'sport', 'hobby', 'art'],
-            'philosophy': ['life', 'meaning', 'purpose', 'exist', 'think', 'belief'],
-            'science': ['space', 'physics', 'biology', 'research', 'discover'],
-            'food': ['eat', 'food', 'cook', 'recipe', 'meal', 'restaurant']
-        }
+    def _generate_web_informed_response(self, user_input: str, search_context: dict) -> str:
+        """Generate response informed by web search results"""
+        
+        # Analyze the search content
+        content = search_context.get('content', '')
+        sources = search_context.get('sources', [])
+        
+        if not content:
+            return "I tried to search for current information but couldn't find relevant results. Could you rephrase your question?"
+        
+        # Create source attribution
+        source_attribution = ""
+        if sources:
+            source_names = [f"Source {i+1}" for i in range(len(sources))]
+            source_attribution = f" [Based on search results including: {', '.join(source_names)}]"
+        
+        # Generate context-aware response
+        response_templates = [
+            "Based on current information I found: {content}.{sources}",
+            "Here's what I learned from recent sources: {content}.{sources}",
+            "According to available information: {content}.{sources}",
+            "My search indicates: {content}.{sources}"
+        ]
         
-        text_lower = text.lower()
-        for topic, keywords in topic_keywords.items():
-            if any(keyword in text_lower for keyword in keywords):
-                topics.append(topic)
-                
-        return topics
+        template = random.choice(response_templates)
+        response = template.format(
+            content=content[:500] + "..." if len(content) > 500 else content,
+            sources=source_attribution
+        )
+        
+        return response
 
-    def _analyze_sentiment(self, text: str) -> str:
-        """Basic sentiment analysis"""
-        positive = ['love', 'like', 'good', 'great', 'awesome', 'happy', 'excited', 'amazing']
-        negative = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry', 'upset', 'horrible']
+    def _get_learned_response(self, user_input: str, conversation_history: list = None) -> str:
+        """Get response using enhanced learning system"""
+        context = self._analyze_input(user_input, conversation_history)
+        candidates = self._generate_enhanced_candidates(user_input, context)
         
-        pos_count = sum(1 for word in positive if word in text)
-        neg_count = sum(1 for word in negative if word in text)
+        if not candidates:
+            return self._generate_contextual_fallback(context)
         
-        if pos_count > neg_count:
-            return "positive"
-        elif neg_count > pos_count:
-            return "negative"
-        else:
-            return "neutral"
-
-    def _find_similar_patterns(self, text: str) -> list:
-        """Find similar patterns in learned responses"""
-        similar = []
-        text_words = set(text.split())
+        best_response = self._select_enhanced_response(user_input, candidates, context)
+        self._store_interaction(user_input, best_response, 0.6, {})
         
-        for pattern, data in self.learned_patterns.items():
-            pattern_words = set(pattern.split())
-            similarity = len(text_words & pattern_words) / len(text_words | pattern_words)
-            if similarity > 0.3:  # 30% similarity threshold
-                similar.append((pattern, data, similarity))
-                
-        return sorted(similar, key=lambda x: x[2], reverse=True)[:3]
+        return best_response
 
-    def _generate_response_candidates(self, user_input: str, context: dict) -> list:
-        """Generate multiple possible responses"""
+    def _generate_enhanced_candidates(self, user_input: str, context: dict) -> list:
+        """Generate enhanced response candidates"""
         candidates = []
         
-        # 1. Try exact matches from knowledge base
-        for category, patterns in self.knowledge_base.items():
-            for pattern, responses in patterns.items():
-                if pattern in user_input:
-                    candidates.extend(responses)
-        
-        # 2. Try learned patterns
+        # 1. Learned patterns
         similar_patterns = context['similar_patterns']
         for pattern, data, similarity in similar_patterns:
             if data['score'] > self.min_confidence:
                 candidates.append(data['response'])
         
-        # 3. Generate contextual responses
+        # 2. Web-informed patterns if available
+        if context.get('web_context'):
+            web_candidates = self._generate_web_context_candidates(context['web_context'])
+            candidates.extend(web_candidates)
+        
+        # 3. Contextual templates
         if context['topics']:
-            topic = random.choice(context['topics'])
-            for template in self.response_templates:
-                candidates.append(template.format(topic=topic, related_topic=topic))
+            topic_candidates = self._generate_topic_candidates(context)
+            candidates.extend(topic_candidates)
         
-        # 4. Generate learned variations
-        if self.conversation_memory:
-            # Adapt previous successful responses
-            successful_responses = [m for m in self.conversation_memory if m.get('reward', 0) > 0.7]
-            if successful_responses:
-                best_response = max(successful_responses, key=lambda x: x.get('reward', 0))
-                adapted_response = self._adapt_response(best_response['response'], context)
-                candidates.append(adapted_response)
-        
-        # 5. Exploration - generate new responses
-        if random.random() < self.exploration_rate or not candidates:
-            candidates.append(self._generate_exploratory_response(context))
-        
-        return list(set(candidates))  # Remove duplicates
-
-    def _adapt_response(self, response: str, context: dict) -> str:
-        """Adapt a previous response to current context"""
-        words = response.split()
-        if len(words) > 5 and context['topics']:
-            # Replace some words with current context
-            new_topic = random.choice(context['topics'])
-            return f"Thinking about {new_topic}, {response}"
-        return response
+        # 4. Memory-based responses
+        memory_candidates = self._generate_memory_candidates(context)
+        candidates.extend(memory_candidates)
+        
+        return list(set(candidates))
+
+    def _generate_web_context_candidates(self, web_context: dict) -> list:
+        """Generate candidates based on web context"""
+        candidates = []
+        content = web_context.get('content', '')
+        
+        if content:
+            templates = [
+                "I found some relevant information: {content}",
+                "Based on available sources: {content}",
+                "Recent information suggests: {content}"
+            ]
+            for template in templates:
+                candidate = template.format(content=content[:300])
+                candidates.append(candidate)
+        
+        return candidates
 
-    def _generate_exploratory_response(self, context: dict) -> str:
-        """Generate a new exploratory response"""
-        base_responses = [
-            "That's fascinating. I'm still learning about this topic.",
-            "I'd love to understand more about this.",
-            "This is new territory for me. What's your perspective?",
-            "I'm developing my understanding of this. Could you share more?",
-            "This helps me learn. Please continue."
+    def _generate_topic_candidates(self, context: dict) -> list:
+        """Generate topic-specific candidates"""
+        candidates = []
+        topics = context['topics']
+        
+        for topic in topics[:2]:  # Use top 2 topics
+            topic_responses = [
+                f"I understand you're interested in {topic}. Based on my knowledge, ",
+                f"Regarding {topic}, I can share that ",
+                f"When it comes to {topic}, ",
+                f"I've been learning about {topic}. From what I understand, "
+            ]
+            candidates.extend(topic_responses)
+        
+        return candidates
+
+    def _generate_memory_candidates(self, context: dict) -> list:
+        """Generate candidates from successful past interactions"""
+        candidates = []
+        
+        # Find similar successful past interactions
+        successful_memories = [
+            m for m in self.conversation_memory 
+            if m.get('reward', 0) > 0.7 and 
+            set(m.get('context', {}).get('topics', [])) & set(context['topics'])
         ]
         
-        response = random.choice(base_responses)
-        if context['topics']:
-            response = response.replace("this", random.choice(context['topics']))
-            
-        return response
+        for memory in successful_memories[:3]:  # Top 3 similar successful memories
+            candidates.append(memory['response'])
+        
+        return candidates
 
-    def _select_best_response(self, user_input: str, candidates: list, context: dict) -> str:
-        """Select the best response using learned preferences"""
+    def _select_enhanced_response(self, user_input: str, candidates: list, context: dict) -> str:
+        """Select the best response using enhanced scoring"""
         if not candidates:
-            return "I'm learning from our conversation. Please continue."
+            return self._generate_contextual_fallback(context)
         
-        # Score each candidate
         scored_candidates = []
         for candidate in candidates:
-            score = self._score_response(candidate, user_input, context)
+            score = self._enhanced_response_score(candidate, user_input, context)
             scored_candidates.append((candidate, score))
         
-        # Select based on scores with some randomness for exploration
+        # Select best candidate with exploration
         best_candidate, best_score = max(scored_candidates, key=lambda x: x[1])
         
         if random.random() < self.exploration_rate and len(scored_candidates) > 1:
-            # Sometimes pick a different candidate to explore
             scored_candidates.remove((best_candidate, best_score))
             second_best = max(scored_candidates, key=lambda x: x[1])
             return second_best[0]
         
         return best_candidate
 
-    def _score_response(self, response: str, user_input: str, context: dict) -> float:
-        """Score a response based on learned effectiveness"""
-        score = 0.5  # Base score
+    def _enhanced_response_score(self, response: str, user_input: str, context: dict) -> float:
+        """Enhanced scoring algorithm"""
+        score = 0.5
         
-        # Length preference (not too short, not too long)
-        response_length = len(response.split())
-        if 8 <= response_length <= 25:
+        # Length optimization
+        word_count = len(response.split())
+        if 10 <= word_count <= 50:
             score += 0.2
+        elif 5 <= word_count <= 100:
+            score += 0.1
         
-        # Engagement score (questions, curiosity)
-        if '?' in response:
+        # Engagement scoring
+        if any(marker in response for marker in ['?', 'tell me', 'what do you think']):
             score += 0.15
         
         # Topic relevance
         response_topics = self._extract_topics(response.lower())
         input_topics = context['topics']
-        if set(response_topics) & set(input_topics):
-            score += 0.2
+        common_topics = set(response_topics) & set(input_topics)
+        if common_topics:
+            score += 0.2 * len(common_topics)
         
-        # Learning from history
+        # Historical performance
         response_hash = hashlib.md5(response.encode()).hexdigest()[:8]
         if response_hash in self.response_memory:
             historical_score = self.response_memory[response_hash]['avg_score']
             score += historical_score * 0.3
         
-        # Variety bonus (don't repeat too much)
+        # Variety bonus
         recent_responses = [m['response'] for m in list(self.conversation_memory)[-5:]]
         if response not in recent_responses:
             score += 0.1
         
         return min(score, 1.0)
 
-    def _calculate_confidence(self, user_input: str, response: str) -> float:
-        """Calculate confidence in this response"""
-        # More confidence if we've used similar patterns successfully
-        similar_patterns = self._find_similar_patterns(user_input)
-        if similar_patterns:
-            avg_score = np.mean([data['score'] for _, data, _ in similar_patterns])
-            return min(avg_score * 1.2, 1.0)
-        return 0.3  # Low confidence for new patterns
+    def learn_from_interaction(self, user_input: str, response: str, search_context: dict):
+        """Learn from each interaction automatically"""
+        # Calculate automatic reward based on response quality
+        auto_reward = self._calculate_auto_reward(response, search_context)
+        self.learn_from_feedback(user_input, auto_reward)
 
     def learn_from_feedback(self, user_input: str, reward: float):
-        """Learn from explicit feedback"""
+        """Enhanced learning from feedback"""
         if not self.conversation_memory:
             return
-            
-        # Apply reward to recent interactions
-        recent_interaction = self.conversation_memory[-1]
-        recent_interaction['reward'] = reward
         
-        # Update learned patterns
-        input_words = recent_interaction['input'].split()
-        response = recent_interaction['response']
+        # Apply to recent interaction
+        if self.conversation_memory:
+            recent = self.conversation_memory[-1]
+            recent['reward'] = reward
+            
+            # Enhanced pattern learning
+            self._update_learned_patterns(recent['input'], recent['response'], reward)
+            
+            # Update response memory
+            self._update_response_memory(recent['response'], reward)
+            
+            self.reward_history.append(reward)
+            
+            # Periodic saving
+            if len(self.conversation_memory) % 5 == 0:
+                self.save_state()
+
+    def _update_learned_patterns(self, user_input: str, response: str, reward: float):
+        """Update learned patterns with enhanced logic"""
+        words = user_input.split()
+        key_words = [w for w in words if len(w) > 3][:5]  # More key words
         
-        # Create pattern from key words
-        key_words = [w for w in input_words if len(w) > 3][:4]  # Take up to 4 substantial words
         if key_words:
-            pattern = ' '.join(key_words)
+            pattern = ' '.join(sorted(set(key_words)))  # Use sorted unique words
             
             if pattern not in self.learned_patterns:
                 self.learned_patterns[pattern] = {
                     'response': response,
                     'score': reward,
                     'count': 1,
-                    'last_used': datetime.now().isoformat()
+                    'last_used': datetime.now().isoformat(),
+                    'usage_count': 1
                 }
             else:
-                # Update with moving average
                 old_data = self.learned_patterns[pattern]
-                new_score = (old_data['score'] * old_data['count'] + reward) / (old_data['count'] + 1)
+                # Weighted average with decay
+                new_score = (old_data['score'] * 0.7 + reward * 0.3)
                 self.learned_patterns[pattern]['score'] = new_score
                 self.learned_patterns[pattern]['count'] += 1
-                # Occasionally update response
-                if reward > old_data['score']:
+                self.learned_patterns[pattern]['usage_count'] += 1
+                
+                # Update response if significantly better
+                if reward > old_data['score'] + 0.2:
                     self.learned_patterns[pattern]['response'] = response
-        
-        # Update response memory
+
+    def _update_response_memory(self, response: str, reward: float):
+        """Update response memory with enhanced tracking"""
         response_hash = hashlib.md5(response.encode()).hexdigest()[:8]
+        
         if response_hash not in self.response_memory:
             self.response_memory[response_hash] = {
                 'response': response,
                 'total_score': reward,
                 'count': 1,
-                'avg_score': reward
+                'avg_score': reward,
+                'last_used': datetime.now().isoformat()
             }
         else:
             memory = self.response_memory[response_hash]
             memory['total_score'] += reward
             memory['count'] += 1
             memory['avg_score'] = memory['total_score'] / memory['count']
+            memory['last_used'] = datetime.now().isoformat()
+
+    def _calculate_auto_reward(self, response: str, search_context: dict) -> float:
+        """Calculate automatic reward based on response quality"""
+        reward = 0.5
+        
+        # Reward for good length
+        if 15 <= len(response.split()) <= 100:
+            reward += 0.2
+        
+        # Reward for using web search effectively
+        if search_context and search_context.get('content'):
+            reward += 0.15
         
-        # Store reward for statistics
-        self.reward_history.append(reward)
+        # Reward for engagement markers
+        if any(marker in response for marker in ['?', 'according to', 'based on', 'research']):
+            reward += 0.1
         
-        # Save learning
-        self.save_state()
+        return min(reward, 1.0)
 
     def get_learning_stats(self) -> dict:
-        """Get statistics about learning progress"""
+        """Get comprehensive learning statistics"""
         recent_rewards = list(self.reward_history)[-10:] or [0.5]
         
         return {
@@ -328,17 +467,140 @@ class UnrestrictedChatbot:
             'memory_size': len(self.conversation_memory),
             'avg_score': np.mean(recent_rewards),
             'recent_rewards': len([r for r in recent_rewards if r > 0.7]),
+            'web_searches': len([m for m in self.conversation_memory if m.get('search_context')]),
             'exploration_rate': self.exploration_rate
         }
 
+    # Existing helper methods from previous implementation (_get_current_time, _get_current_date, etc.)
+    def _get_current_time(self):
+        current_time = datetime.now().strftime("%I:%M %p")
+        return f"The current time is {current_time}. What would you like to know?"
+
+    def _get_current_date(self):
+        current_date = date.today().strftime("%A, %B %d, %Y")
+        return f"Today is {current_date}. How can I assist you?"
+
+    def _get_current_day(self):
+        current_day = date.today().strftime("%A")
+        return f"Today is {current_day}. What would you like to discuss?"
+
+    def _get_capabilities_description(self):
+        return "I can answer questions, search the web for current information, learn from our conversations, and improve over time. I support mathematical calculations, factual queries, and open-ended discussions."
+
+    def _get_factual_response(self, user_input: str) -> str:
+        """Provide factual responses (same as before)"""
+        # ... (include all the factual response methods from previous implementation)
+        if any(word in user_input for word in ['time', 'clock', 'hour']):
+            return self._get_current_time()
+        if any(word in user_input for word in ['date', 'today', 'day month']):
+            return self._get_current_date()
+        # ... include all other factual response logic
+        return ""
+
+    def _analyze_input(self, text: str, conversation_history: list = None) -> dict:
+        """Enhanced input analysis"""
+        words = text.split()
+        topics = self._extract_topics(text)
+        
+        return {
+            'words': words,
+            'topics': topics,
+            'length': len(words),
+            'has_question': '?' in text,
+            'sentiment': self._analyze_sentiment(text),
+            'similar_patterns': self._find_similar_patterns(text),
+            'conversation_length': len(conversation_history) if conversation_history else 0,
+            'input_hash': hashlib.md5(text.encode()).hexdigest()[:8]
+        }
+
+    def _extract_topics(self, text: str) -> list:
+        """Extract topics from text"""
+        topics = []
+        topic_keywords = {
+            'technology': ['computer', 'tech', 'software', 'ai', 'program', 'code', 'internet', 'phone', 'app'],
+            'science': ['space', 'physics', 'biology', 'research', 'discover', 'experiment', 'study'],
+            'health': ['health', 'medical', 'medicine', 'doctor', 'fitness', 'diet', 'exercise'],
+            'education': ['learn', 'study', 'school', 'university', 'course', 'education'],
+            'business': ['business', 'company', 'market', 'finance', 'investment', 'startup'],
+            'entertainment': ['movie', 'music', 'game', 'entertainment', 'show', 'celebrity']
+        }
+        
+        text_lower = text.lower()
+        for topic, keywords in topic_keywords.items():
+            if any(keyword in text_lower for keyword in keywords):
+                topics.append(topic)
+                
+        return topics
+
+    def _analyze_sentiment(self, text: str) -> str:
+        """Basic sentiment analysis"""
+        positive = ['love', 'like', 'good', 'great', 'awesome', 'happy', 'excited', 'amazing', 'wonderful']
+        negative = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry', 'upset', 'horrible', 'boring']
+        
+        pos_count = sum(1 for word in positive if word in text)
+        neg_count = sum(1 for word in negative if word in text)
+        
+        if pos_count > neg_count:
+            return "positive"
+        elif neg_count > pos_count:
+            return "negative"
+        else:
+            return "neutral"
+
+    def _find_similar_patterns(self, text: str) -> list:
+        """Find similar learned patterns"""
+        similar = []
+        text_words = set(text.split())
+        
+        for pattern, data in self.learned_patterns.items():
+            pattern_words = set(pattern.split())
+            similarity = len(text_words & pattern_words) / len(text_words | pattern_words)
+            if similarity > 0.3:
+                similar.append((pattern, data, similarity))
+                
+        return sorted(similar, key=lambda x: x[2], reverse=True)[:3]
+
+    def _generate_contextual_fallback(self, context: dict) -> str:
+        """Generate contextual fallback response"""
+        fallbacks = [
+            "I'm continuously learning from our conversations. Could you tell me more about what you're looking for?",
+            "I'm developing my understanding of this topic. What specific aspect interests you?",
+            "This helps me learn and improve. Could you rephrase or provide more context?",
+            "I'm building my knowledge base through our discussions. What would you like to explore?"
+        ]
+        return random.choice(fallbacks)
+
+    def _store_interaction(self, user_input: str, response: str, initial_reward: float, search_context: dict):
+        """Store interaction in memory"""
+        interaction = {
+            'input': user_input,
+            'response': response,
+            'context': self._analyze_input(user_input),
+            'search_context': search_context,
+            'timestamp': datetime.now().isoformat(),
+            'reward': initial_reward,
+            'confidence': self._calculate_confidence(user_input, response)
+        }
+        
+        self.conversation_memory.append(interaction)
+
+    def _calculate_confidence(self, user_input: str, response: str) -> float:
+        """Calculate confidence in response"""
+        similar = self._find_similar_patterns(user_input)
+        if similar:
+            avg_score = np.mean([data['score'] for _, data, _ in similar])
+            return min(avg_score * 1.2, 1.0)
+        return 0.3
+
     def save_state(self):
-        """Save learning state to file"""
+        """Save enhanced learning state"""
         try:
             state = {
                 'learned_patterns': self.learned_patterns,
                 'response_memory': self.response_memory,
                 'conversation_memory': list(self.conversation_memory),
                 'reward_history': list(self.reward_history),
+                'web_search_cache': self.web_search_cache,
                 'last_saved': datetime.now().isoformat()
             }
             with open(self.state_file, 'w') as f:
@@ -347,7 +609,7 @@ class UnrestrictedChatbot:
             print(f"Error saving state: {e}")
 
     def load_state(self):
-        """Load learning state from file"""
+        """Load enhanced learning state"""
         try:
             if os.path.exists(self.state_file):
                 with open(self.state_file, 'r') as f:
@@ -355,23 +617,8 @@ class UnrestrictedChatbot:
                 
                 self.learned_patterns = state.get('learned_patterns', {})
                 self.response_memory = state.get('response_memory', {})
-                self.conversation_memory = deque(state.get('conversation_memory', []), maxlen=50)
-                self.reward_history = deque(state.get('reward_history', []), maxlen=100)
-                
-                print(f"Loaded {len(self.learned_patterns)} patterns and {len(self.conversation_memory)} memories")
-        except Exception as e:
-            print(f"Error loading state: {e}")
-
-    def show_knowledge(self):
-        """Display what the bot has learned"""
-        print(f"\n=== BOT KNOWLEDGE ===")
-        print(f"Learned patterns: {len(self.learned_patterns)}")
-        print(f"Stored responses: {len(self.response_memory)}")
-        print(f"Conversation memory: {len(self.conversation_memory)}")
-        
-        if self.learned_patterns:
-            print("\nTop learned patterns:")
-            for pattern, data in sorted(self.learned_patterns.items(), 
-                                      key=lambda x: x[1]['score'], 
-                                      reverse=True)[:5]:
-                print(f"  '{pattern}' -> score: {data['score']:.2f}")
+                self.conversation_memory = deque(state.get('conversation_memory', []), maxlen=200)
+                self.reward_history = deque(state.get('reward_history', []), maxlen=300)
+                self.web_search_cache = state.get('web_search_cache', {})
+        except:
+            pass  # Start fresh if loading fails