Update self_learning_bot.py

self_learning_bot.py

@@ -10,519 +10,412 @@ import requests
 from collections import deque
 import time
 from typing import Dict, List, Any, Tuple
-import markdown
 from bs4 import BeautifulSoup
+import urllib.parse
 
-class EnhancedLearningBot:
-    def __init__(self, state_file="/tmp/chatbot_enhanced_state.json"):
+class WebEnhancedBot:
+    def __init__(self, state_file="/tmp/web_bot_state.json"):
         self.state_file = state_file
-        self.conversation_memory = deque(maxlen=200)
+        self.conversation_memory = deque(maxlen=150)
         self.learned_patterns = {}
         self.response_memory = {}
-        self.reward_history = deque(maxlen=300)
-        self.web_search_cache = {}
+        self.reward_history = deque(maxlen=200)
+        self.web_cache = {}
         
-        # Enhanced learning parameters
-        self.learning_rate = 0.4
-        self.exploration_rate = 0.15
-        self.min_confidence = 0.5
+        # Learning parameters
+        self.learning_rate = 0.3
+        self.exploration_rate = 0.1
         
-        # Web search configuration
-        self.search_enabled = True
-        self.search_timeout = 10
-        self.max_context_length = 6000
+        # Web search settings
+        self.search_timeout = 15
+        self.max_results = 3
         
         # Load existing state
         self.load_state()
         
-        # 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
-        }
-        
-        print(f"Enhanced bot initialized with {len(self.learned_patterns)} learned patterns")
+        print(f"Web-enhanced bot initialized with {len(self.learned_patterns)} learned patterns")
 
-    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 chat_with_web_search(self, user_input: str, use_search: bool = True) -> Tuple[str, bool]:
+        """Main chat method that actually uses web search to answer questions"""
+        
+        # Check if this is a question that needs web search
+        needs_search = self._should_search_web(user_input) and use_search
+        
+        if needs_search:
+            # Actually search and get real answers
+            web_content = self._get_web_content(user_input)
+            if web_content and web_content.get('content'):
+                response = self._create_web_answer(user_input, web_content)
+                self._store_interaction(user_input, response, 0.8, web_content)
+                return response, True
+        
+        # Fallback to learned responses
+        response = self._get_learned_response(user_input)
+        self._store_interaction(user_input, response, 0.5, {})
+        return response, False
 
-    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'
+    def _should_search_web(self, user_input: str) -> bool:
+        """Determine if we should search the web for this query"""
+        input_lower = user_input.lower()
+        
+        # Questions that need current information
+        current_info_indicators = [
+            'current', 'recent', 'latest', 'today', 'now', 'breaking', 'news',
+            'what happened', 'when did', 'update on', 'new', 'just happened'
         ]
         
-        if any(indicator in user_input for indicator in current_indicators):
-            return True
+        # Factual questions that might need verification
+        factual_questions = [
+            'what is', 'who is', 'where is', 'when was', 'how to', 'why does',
+            'explain', 'tell me about', 'information about', 'details about'
+        ]
+        
+        # Specific topics that change frequently
+        dynamic_topics = [
+            'weather', 'temperature', 'forecast', 'stock', 'price', 'crypto',
+            'sports', 'game', 'score', 'election', 'politics', 'celebrity'
+        ]
         
-        # Complex questions that might need updated information
-        if any(word in user_input for word in ['best', 'top', 'review', 'compare', 'versus']):
+        # Check if input matches any search criteria
+        if any(indicator in input_lower for indicator in current_info_indicators):
+            return True
+            
+        if any(question in input_lower for question in factual_questions):
+            return True
+            
+        if any(topic in input_lower for topic in dynamic_topics):
+            return True
+            
+        # Questions with question words
+        if any(word in input_lower for word in ['what', 'who', 'where', 'when', 'how', 'why']) and '?' in user_input:
             return True
             
         return False
 
-    def _perform_web_search(self, query: str) -> dict:
-        """Perform web search using open-source alternatives"""
+    def _get_web_content(self, query: str) -> Dict[str, Any]:
+        """Get actual web content for answering questions"""
         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
+            # Try multiple search methods
+            search_results = self._search_brave(query) or self._search_duckduckgo(query)
             
+            if search_results and search_results.get('results'):
+                # Extract actual content from the top result
+                content = self._extract_meaningful_content(search_results['results'][0])
+                return {
+                    'content': content,
+                    'source': search_results['results'][0].get('url', ''),
+                    'query': query,
+                    'results_count': len(search_results['results'])
+                }
         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"
-        ]
         
-        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 {}
+
+    def _search_brave(self, query: str) -> Dict[str, Any]:
+        """Search using Brave Search (free tier)"""
+        try:
+            # Brave Search API (free for limited use)
+            url = f"https://api.search.brave.com/res/v1/web/search"
+            headers = {
+                "Accept": "application/json",
+                "X-Subscription-Token": "BSA-Your-Free-Key-Here"  # Get free key from brave.com
+            }
+            params = {
+                "q": query,
+                "count": self.max_results
+            }
+            
+            response = requests.get(url, headers=headers, params=params, timeout=self.search_timeout)
+            if response.status_code == 200:
+                data = response.json()
+                results = []
+                for web_result in data.get('web', {}).get('results', [])[:self.max_results]:
+                    results.append({
+                        'title': web_result.get('title', ''),
+                        'url': web_result.get('url', ''),
+                        'description': web_result.get('description', '')
+                    })
+                return {'results': results}
+        except:
+            pass
+        return {}
+
+    def _search_duckduckgo(self, query: str) -> Dict[str, Any]:
+        """Fallback to DuckDuckGo instant answers and web results"""
+        try:
+            # DuckDuckGo Instant Answer API
+            ia_url = f"https://api.duckduckgo.com/"
+            params = {
+                "q": query,
+                "format": "json",
+                "no_html": "1",
+                "skip_disambig": "1"
+            }
+            
+            response = requests.get(ia_url, params=params, timeout=self.search_timeout)
+            if response.status_code == 200:
+                data = response.json()
+                
+                # Check for instant answer
+                if data.get('AbstractText'):
                     return {
-                        'results': data.get('results', [])[:3],  # Top 3 results
-                        'instance': instance
+                        'results': [{
+                            'title': data.get('Heading', 'Instant Answer'),
+                            'url': data.get('AbstractURL', ''),
+                            'description': data.get('AbstractText', '')
+                        }]
                     }
-            except:
-                continue
-        
-        return {'results': []}
+                
+                # Check for related topics
+                if data.get('RelatedTopics'):
+                    for topic in data['RelatedTopics'][:self.max_results]:
+                        if topic.get('Text'):
+                            return {
+                                'results': [{
+                                    'title': topic.get('FirstURL', '').split('/')[-1].replace('_', ' '),
+                                    'url': topic.get('FirstURL', ''),
+                                    'description': topic.get('Text', '')
+                                }]
+                            }
+            
+            # Fallback to HTML scraping
+            return self._scrape_duckduckgo_html(query)
+            
+        except Exception as e:
+            print(f"DuckDuckGo search error: {e}")
+            return {}
 
-    def _search_duckduckgo(self, query: str) -> dict:
-        """Fallback to DuckDuckGo HTML scraping"""
+    def _scrape_duckduckgo_html(self, query: str) -> Dict[str, Any]:
+        """Scrape DuckDuckGo HTML results as final fallback"""
         try:
-            url = f"https://html.duckduckgo.com/html/?q={query.replace(' ', '+')}"
+            url = f"https://html.duckduckgo.com/html/?q={urllib.parse.quote(query)}"
             headers = {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                'Accept-Language': 'en-US,en;q=0.5',
             }
-            response = requests.get(url, headers=headers, timeout=self.search_timeout)
             
-            # Simple HTML parsing for results
+            response = requests.get(url, headers=headers, timeout=self.search_timeout)
             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')
+            results = []
+            for result in soup.find_all('div', class_='result')[:self.max_results]:
+                title_elem = result.find('a', class_='result__a')
+                snippet_elem = result.find('a', class_='result__snippet')
                 
-                if title_elem and link_elem:
+                if title_elem and snippet_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 ''
+                        'url': title_elem.get('href', ''),
+                        'description': snippet_elem.get_text().strip()
                     })
             
-            return {'results': results}
+            return {'results': results} if results else {}
+            
         except Exception as e:
-            print(f"DuckDuckGo search error: {e}")
-            return {'results': []}
+            print(f"DDG HTML scraping error: {e}")
+            return {}
 
-    def _process_search_results(self, search_results: dict, original_query: str) -> dict:
-        """Process and extract useful content from search results"""
+    def _extract_meaningful_content(self, result: Dict) -> str:
+        """Extract meaningful content from search result"""
+        title = result.get('title', '')
+        description = result.get('description', '')
+        url = result.get('url', '')
+        
+        # Combine title and description for context
         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
+        if title:
+            content_parts.append(title)
+        if description:
+            content_parts.append(description)
         
-        # Combine all content
-        full_content = " ".join(content_parts)[:self.max_context_length]
+        full_content = ". ".join(content_parts)
         
-        return {
-            'content': full_content,
-            'sources': sources,
-            'original_query': original_query,
-            'result_count': len(sources)
-        }
-
-    def _generate_web_informed_response(self, user_input: str, search_context: dict) -> str:
-        """Generate response informed by web search results"""
+        # Clean up the content
+        full_content = re.sub(r'\[\d+\]', '', full_content)  # Remove citation numbers
+        full_content = re.sub(r'\s+', ' ', full_content)  # Normalize whitespace
         
-        # Analyze the search content
-        content = search_context.get('content', '')
-        sources = search_context.get('sources', [])
+        return full_content.strip()
+
+    def _create_web_answer(self, user_input: str, web_content: Dict) -> str:
+        """Create an actual answer using web content"""
+        content = web_content.get('content', '')
+        source = web_content.get('source', '')
         
         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}"
-        ]
-        
-        template = random.choice(response_templates)
-        response = template.format(
-            content=content[:500] + "..." if len(content) > 500 else content,
-            sources=source_attribution
-        )
-        
-        return response
+            return "I searched but couldn't find specific information about that. Could you try rephrasing your question?"
+        
+        # Analyze the type of question and create appropriate response
+        question_type = self._analyze_question_type(user_input)
+        
+        if question_type == "factual":
+            return self._format_factual_answer(user_input, content, source)
+        elif question_type == "current_events":
+            return self._format_current_events_answer(user_input, content, source)
+        elif question_type == "how_to":
+            return self._format_how_to_answer(user_input, content, source)
+        elif question_type == "weather":
+            return self._format_weather_answer(user_input, content, source)
+        else:
+            return self._format_general_answer(user_input, content, source)
+
+    def _analyze_question_type(self, user_input: str) -> str:
+        """Analyze what type of question this is"""
+        input_lower = user_input.lower()
+        
+        if any(word in input_lower for word in ['weather', 'temperature', 'forecast']):
+            return "weather"
+        elif any(word in input_lower for word in ['how to', 'how do i', 'tutorial', 'guide']):
+            return "how_to"
+        elif any(word in input_lower for word in ['news', 'current', 'recent', 'breaking', 'today']):
+            return "current_events"
+        elif any(word in input_lower for word in ['what is', 'who is', 'where is', 'when was']):
+            return "factual"
+        else:
+            return "general"
 
-    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)
+    def _format_factual_answer(self, question: str, content: str, source: str) -> str:
+        """Format factual answers"""
+        # Extract the most relevant sentence
+        sentences = content.split('. ')
+        relevant_sentence = sentences[0] if sentences else content
         
-        if not candidates:
-            return self._generate_contextual_fallback(context)
+        answer = f"**According to web sources:** {relevant_sentence}"
         
-        best_response = self._select_enhanced_response(user_input, candidates, context)
-        self._store_interaction(user_input, best_response, 0.6, {})
+        if len(sentences) > 1:
+            additional_info = '. '.join(sentences[1:3])
+            answer += f" {additional_info}."
         
-        return best_response
+        return answer
 
-    def _generate_enhanced_candidates(self, user_input: str, context: dict) -> list:
-        """Generate enhanced response candidates"""
-        candidates = []
-        
-        # 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'])
-        
-        # 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_candidates = self._generate_topic_candidates(context)
-            candidates.extend(topic_candidates)
-        
-        # 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)
+    def _format_current_events_answer(self, question: str, content: str, source: str) -> str:
+        """Format current events answers"""
+        sentences = content.split('. ')
         
-        return candidates
+        answer = f"**Latest information:** {content[:400]}"
+        if len(content) > 400:
+            answer += "..."
+            
+        return answer
 
-    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)
+    def _format_how_to_answer(self, question: str, content: str, source: str) -> str:
+        """Format how-to answers"""
+        # Look for instructional language
+        instructions = []
+        sentences = content.split('. ')
         
-        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'])
-        ]
+        for sentence in sentences[:4]:  # Take first 4 sentences
+            if any(word in sentence.lower() for word in ['step', 'first', 'then', 'next', 'after']):
+                instructions.append(sentence)
         
-        for memory in successful_memories[:3]:  # Top 3 similar successful memories
-            candidates.append(memory['response'])
+        if instructions:
+            answer = "**Here's what I found:**\n" + "\n".join(f"• {inst}" for inst in instructions[:3])
+        else:
+            answer = f"**Based on available information:** {sentences[0] if sentences else content}"
         
-        return candidates
+        return answer
 
-    def _select_enhanced_response(self, user_input: str, candidates: list, context: dict) -> str:
-        """Select the best response using enhanced scoring"""
-        if not candidates:
-            return self._generate_contextual_fallback(context)
+    def _format_weather_answer(self, question: str, content: str, source: str) -> str:
+        """Format weather-related answers"""
+        # Extract location from question
+        location = self._extract_location(question)
         
-        scored_candidates = []
-        for candidate in candidates:
-            score = self._enhanced_response_score(candidate, user_input, context)
-            scored_candidates.append((candidate, score))
+        # Look for temperature and conditions in content
+        temp_match = re.search(r'(\d+)\s*°?[CF]', content)
+        condition_match = re.search(r'(sunny|rain|cloud|snow|clear|storm)', content.lower())
         
-        # Select best candidate with exploration
-        best_candidate, best_score = max(scored_candidates, key=lambda x: x[1])
+        answer_parts = []
+        if location:
+            answer_parts.append(f"**Weather for {location}:**")
         
-        if random.random() < self.exploration_rate and len(scored_candidates) > 1:
-            scored_candidates.remove((best_candidate, best_score))
-            second_best = max(scored_candidates, key=lambda x: x[1])
-            return second_best[0]
+        if temp_match:
+            answer_parts.append(f"Temperature around {temp_match.group(1)}°F")
         
-        return best_candidate
-
-    def _enhanced_response_score(self, response: str, user_input: str, context: dict) -> float:
-        """Enhanced scoring algorithm"""
-        score = 0.5
-        
-        # Length optimization
-        word_count = len(response.split())
-        if 10 <= word_count <= 50:
-            score += 0.2
-        elif 5 <= word_count <= 100:
-            score += 0.1
-        
-        # 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']
-        common_topics = set(response_topics) & set(input_topics)
-        if common_topics:
-            score += 0.2 * len(common_topics)
-        
-        # 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
-        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 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):
-        """Enhanced learning from feedback"""
-        if not self.conversation_memory:
-            return
-        
-        # 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
+        if condition_match:
+            answer_parts.append(f"Conditions: {condition_match.group(1).title()}")
         
-        if 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(),
-                    'usage_count': 1
-                }
-            else:
-                old_data = self.learned_patterns[pattern]
-                # 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
-                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
-
-    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,
-                'last_used': datetime.now().isoformat()
-            }
+        if answer_parts:
+            return " ".join(answer_parts) + f"\n*Source: {source}*" if source else ""
         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
-        
-        # Reward for engagement markers
-        if any(marker in response for marker in ['?', 'according to', 'based on', 'research']):
-            reward += 0.1
+            return f"**Weather information:** {content[:300]}"
+
+    def _format_general_answer(self, question: str, content: str, source: str) -> str:
+        """Format general answers"""
+        return f"**I found this information:** {content[:500]}" + ("..." if len(content) > 500 else "")
+
+    def _extract_location(self, text: str) -> str:
+        """Extract location from text (simple version)"""
+        # Common city/country names
+        locations = {
+            'new york', 'london', 'paris', 'tokyo', 'berlin', 'sydney', 'toronto',
+            'mumbai', 'beijing', 'moscow', 'dubai', 'rome', 'madrid', 'amsterdam',
+            'chicago', 'los angeles', 'san francisco', 'seattle', 'boston', 'miami'
+        }
         
-        return min(reward, 1.0)
-
-    def get_learning_stats(self) -> dict:
-        """Get comprehensive learning statistics"""
-        recent_rewards = list(self.reward_history)[-10:] or [0.5]
+        text_lower = text.lower()
+        for location in locations:
+            if location in text_lower:
+                return location.title()
         
-        return {
-            'patterns': len(self.learned_patterns),
-            '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)
-        
+    def _get_learned_response(self, user_input: str) -> str:
+        """Get response from learned patterns"""
+        context = self._analyze_input(user_input)
+        
+        # Try learned patterns first
+        similar_patterns = self._find_similar_patterns(user_input)
+        if similar_patterns:
+            best_pattern = max(similar_patterns, key=lambda x: x[1]['score'])
+            if best_pattern[1]['score'] > 0.6:
+                return best_pattern[1]['response']
+        
+        # Generate contextual response
+        return self._generate_contextual_response(user_input, context)
+
+    def _generate_contextual_response(self, user_input: str, context: dict) -> str:
+        """Generate contextual response when no web results"""
+        if context['has_question']:
+            responses = [
+                "That's an interesting question. Based on my knowledge, ",
+                "I understand you're asking about ",
+                "That's a great question. From what I've learned, "
+            ]
+            base = random.choice(responses)
+            
+            if context['topics']:
+                return base + f"{random.choice(context['topics'])}. Could you tell me more about what specifically interests you?"
+            else:
+                return base + "this topic. I'm constantly learning from our conversations."
+        
+        # Conversational responses
+        conversational = [
+            "I appreciate you sharing that. What are your thoughts on this?",
+            "That's interesting. Tell me more about your perspective.",
+            "I understand. How does that relate to your experiences?",
+            "That's fascinating. I'm learning from our conversation."
+        ]
+        return random.choice(conversational)
+
+    def _analyze_input(self, text: str) -> dict:
+        """Analyze user input"""
         return {
-            'words': words,
-            'topics': topics,
-            'length': len(words),
+            'words': text.split(),
+            'topics': self._extract_topics(text),
             '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]
+            'sentiment': self._analyze_sentiment(text)
         }
 
     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']
+            'technology': ['computer', 'tech', 'software', 'ai', 'program', 'code'],
+            'science': ['space', 'physics', 'biology', 'research', 'discover'],
+            'sports': ['game', 'sports', 'team', 'player', 'score'],
+            'entertainment': ['movie', 'music', 'show', 'celebrity'],
+            'health': ['health', 'medical', 'fitness', 'diet']
         }
         
         text_lower = text.lower()
@@ -534,8 +427,8 @@ class EnhancedLearningBot:
 
     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']
+        positive = ['love', 'like', 'good', 'great', 'awesome', 'happy']
+        negative = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry']
         
         pos_count = sum(1 for word in positive if word in text)
         neg_count = sum(1 for word in negative if word in text)
@@ -556,69 +449,91 @@ class EnhancedLearningBot:
             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))
+                similar.append((pattern, data))
                 
-        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)
+        return similar
 
-    def _store_interaction(self, user_input: str, response: str, initial_reward: float, search_context: dict):
+    def _store_interaction(self, user_input: str, response: str, reward: float, web_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)
+            'reward': reward,
+            'web_context': web_context,
+            'timestamp': datetime.now().isoformat()
         }
         
         self.conversation_memory.append(interaction)
+        
+        # Learn from this interaction
+        self._update_learning(user_input, response, reward)
+
+    def _update_learning(self, user_input: str, response: str, reward: float):
+        """Update learning from interaction"""
+        # Extract key phrases for pattern learning
+        words = [w for w in user_input.split() if len(w) > 3][:4]
+        if words:
+            pattern = ' '.join(words)
+            
+            if pattern not in self.learned_patterns:
+                self.learned_patterns[pattern] = {
+                    'response': response,
+                    'score': reward,
+                    'count': 1
+                }
+            else:
+                old = self.learned_patterns[pattern]
+                new_score = (old['score'] * old['count'] + reward) / (old['count'] + 1)
+                self.learned_patterns[pattern]['score'] = new_score
+                self.learned_patterns[pattern]['count'] += 1
+        
+        # Store reward
+        self.reward_history.append(reward)
+        
+        # Periodic save
+        if len(self.conversation_memory) % 10 == 0:
+            self.save_state()
+
+    def learn_from_feedback(self, user_input: str, reward: float):
+        """Learn from explicit feedback"""
+        if self.conversation_memory:
+            recent = self.conversation_memory[-1]
+            recent['reward'] = reward
+            self._update_learning(recent['input'], recent['response'], reward)
 
-    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 get_learning_stats(self) -> dict:
+        """Get learning statistics"""
+        recent_rewards = list(self.reward_history)[-10:] or [0.5]
+        
+        return {
+            'patterns': len(self.learned_patterns),
+            '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])
+        }
 
     def save_state(self):
-        """Save enhanced learning state"""
+        """Save 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()
+                'reward_history': list(self.reward_history)
             }
             with open(self.state_file, 'w') as f:
                 json.dump(state, f, indent=2)
         except Exception as e:
-            print(f"Error saving state: {e}")
+            print(f"Save error: {e}")
 
     def load_state(self):
-        """Load enhanced learning state"""
+        """Load learning state"""
         try:
             if os.path.exists(self.state_file):
                 with open(self.state_file, 'r') as f:
                     state = json.load(f)
                 
                 self.learned_patterns = state.get('learned_patterns', {})
-                self.response_memory = state.get('response_memory', {})
-                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', {})
+                self.conversation_memory = deque(state.get('conversation_memory', []), maxlen=150)
+                self.reward_history = deque(state.get('reward_history', []), maxlen=200)
         except:
-            pass  # Start fresh if loading fails
+            pass