Update self_learning_bot.py

self_learning_bot.py

@@ -8,345 +8,243 @@ import math
 import hashlib
 import requests
 from collections import deque
-import time
-from typing import Dict, List, Any, Tuple
 from bs4 import BeautifulSoup
 import urllib.parse
+import feedparser
 
-class WebEnhancedBot:
-    def __init__(self, state_file="/tmp/web_bot_state.json"):
+class FreeWebBot:
+    def __init__(self, state_file="/tmp/free_bot_state.json"):
         self.state_file = state_file
-        self.conversation_memory = deque(maxlen=150)
+        self.conversation_memory = deque(maxlen=200)
         self.learned_patterns = {}
         self.response_memory = {}
-        self.reward_history = deque(maxlen=200)
-        self.web_cache = {}
+        self.reward_history = deque(maxlen=300)
         
         # Learning parameters
         self.learning_rate = 0.3
         self.exploration_rate = 0.1
         
-        # Web search settings
-        self.search_timeout = 15
-        self.max_results = 3
+        # Web settings
+        self.search_timeout = 10
+        self.user_agent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        
+        # Free news sources (RSS feeds)
+        self.news_feeds = {
+            "general": [
+                "https://feeds.bbci.co.uk/news/rss.xml",
+                "https://rss.cnn.com/rss/edition.rss",
+                "https://feeds.reuters.com/reuters/topNews",
+            ],
+            "technology": [
+                "https://feeds.arstechnica.com/arstechnica/index",
+                "https://techcrunch.com/feed/",
+            ],
+            "sports": [
+                "https://feeds.espn.com/espn/rss/news",
+            ]
+        }
         
         # Load existing state
         self.load_state()
         
-        print(f"Web-enhanced bot initialized with {len(self.learned_patterns)} learned patterns")
+        print(f"Free web bot initialized with {len(self.learned_patterns)} learned patterns")
 
-    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
+    def chat(self, user_input, use_web_search=True):
+        """Main chat method - returns (response, search_used, sources)"""
+        user_input = user_input.strip()
+        if not user_input:
+            return "Please enter a message.", False, []
+        
+        # First, try factual responses
+        factual_response = self._get_factual_response(user_input)
+        if factual_response:
+            return factual_response, False, []
+        
+        # Try free web search for current information
+        if use_web_search and self._should_search_web(user_input):
+            web_content, sources = self._free_web_search(user_input)
+            if web_content and web_content.strip():
+                response = self._create_web_answer(user_input, web_content, sources)
+                self._store_interaction(user_input, response, 0.8, sources)
+                return response, True, sources
         
         # Fallback to learned responses
         response = self._get_learned_response(user_input)
-        self._store_interaction(user_input, response, 0.5, {})
-        return response, False
+        self._store_interaction(user_input, response, 0.5, [])
+        return response, False, []
 
-    def _should_search_web(self, user_input: str) -> bool:
+    def _should_search_web(self, user_input):
         """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'
-        ]
-        
-        # 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'
+        search_triggers = [
+            'news', 'current', 'latest', 'today', 'recent', 'update',
+            'weather', 'forecast', 'temperature',
+            'sports', 'score', 'game', 'match',
+            'stock', 'crypto', 'bitcoin', 'price',
+            'how to', 'tutorial', 'guide', 'explain',
+            'what is', 'who is', 'where is', 'when was',
+            'breaking', 'headlines'
         ]
         
-        # 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
+        return any(trigger in input_lower for trigger in search_triggers)
+
+    def _free_web_search(self, query):
+        """Perform free web search using multiple methods"""
+        sources = []
+        all_content = []
+        
+        # Method 1: RSS Feeds for news/current events
+        if any(topic in query.lower() for topic in ['news', 'current', 'latest', 'today', 'breaking']):
+            feed_content = self._search_rss_feeds(query)
+            all_content.extend(feed_content)
+            if feed_content:
+                sources.append("News Feeds")
+
+        # Method 2: Wikipedia for factual information
+        if any(word in query.lower() for word in ['what is', 'who is', 'explain', 'definition']):
+            wiki_content = self._search_wikipedia(query)
+            if wiki_content:
+                all_content.append(wiki_content)
+                sources.append("Wikipedia")
+
+        # Method 3: DuckDuckGo for general search
+        ddg_content = self._search_duckduckgo(query)
+        if ddg_content:
+            all_content.append(ddg_content)
+            sources.append("Web Search")
+
+        # Method 4: Weather information
+        if any(word in query.lower() for word in ['weather', 'temperature', 'forecast']):
+            weather_content = self._get_weather_info(query)
+            if weather_content:
+                all_content.append(weather_content)
+                sources.append("Weather Service")
 
-    def _get_web_content(self, query: str) -> Dict[str, Any]:
-        """Get actual web content for answering questions"""
+        # Combine all content
+        combined_content = " ".join(all_content)
+        return combined_content, sources
+
+    def _search_rss_feeds(self, query):
+        """Search RSS feeds for current information"""
+        content = []
+        query_words = query.lower().split()
+        
+        # Determine feed category based on query
+        category = "general"
+        if any(word in query.lower() for word in ['tech', 'technology', 'ai', 'computer', 'software']):
+            category = "technology"
+        elif any(word in query.lower() for word in ['sports', 'game', 'score', 'match', 'team']):
+            category = "sports"
+        
         try:
-            # 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'])
-                }
+            for feed_url in self.news_feeds.get(category, self.news_feeds["general"]):
+                try:
+                    feed = feedparser.parse(feed_url)
+                    for entry in feed.entries[:5]:  # Top 5 entries
+                        title = entry.get('title', '')
+                        summary = entry.get('summary', '')
+                        
+                        # Check if entry matches query
+                        entry_text = f"{title} {summary}".lower()
+                        if any(word in entry_text for word in query_words) or len(query_words) < 2:
+                            content.append(f"{title}: {summary}")
+                            
+                        if len(content) >= 3:  # Limit to 3 results
+                            break
+                except Exception as e:
+                    print(f"Error parsing feed {feed_url}: {e}")
+                    continue
+                    
+                if content:
+                    break
+                    
         except Exception as e:
-            print(f"Web search error: {e}")
+            print(f"RSS feed error: {e}")
         
-        return {}
+        return content
 
-    def _search_brave(self, query: str) -> Dict[str, Any]:
-        """Search using Brave Search (free tier)"""
+    def _search_wikipedia(self, query):
+        """Search Wikipedia for factual information"""
         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
-            }
+            # Clean query for Wikipedia
+            clean_query = re.sub(r'(what is|who is|explain|definition of)', '', query, flags=re.IGNORECASE).strip()
+            clean_query = clean_query.replace('?', '').strip()
             
-            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"
-            }
+            if not clean_query:
+                return ""
             
-            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': [{
-                            'title': data.get('Heading', 'Instant Answer'),
-                            'url': data.get('AbstractURL', ''),
-                            'description': data.get('AbstractText', '')
-                        }]
-                    }
-                
-                # 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', '')
-                                }]
-                            }
+            # Wikipedia API (completely free)
+            url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{urllib.parse.quote(clean_query)}"
             
-            # Fallback to HTML scraping
-            return self._scrape_duckduckgo_html(query)
+            response = requests.get(
+                url,
+                headers={'User-Agent': self.user_agent},
+                timeout=self.search_timeout
+            )
             
+            if response.status_code == 200:
+                data = response.json()
+                extract = data.get('extract', '')
+                if extract:
+                    return f"According to Wikipedia: {extract}"
+                    
         except Exception as e:
-            print(f"DuckDuckGo search error: {e}")
-            return {}
+            print(f"Wikipedia search error: {e}")
+        
+        return ""
 
-    def _scrape_duckduckgo_html(self, query: str) -> Dict[str, Any]:
-        """Scrape DuckDuckGo HTML results as final fallback"""
+    def _search_duckduckgo(self, query):
+        """Search DuckDuckGo for general information"""
         try:
             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 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+                'User-Agent': self.user_agent,
                 '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)
             soup = BeautifulSoup(response.text, 'html.parser')
             
             results = []
-            for result in soup.find_all('div', class_='result')[:self.max_results]:
+            for result in soup.find_all('div', class_='result')[:3]:
                 title_elem = result.find('a', class_='result__a')
                 snippet_elem = result.find('a', class_='result__snippet')
                 
                 if title_elem and snippet_elem:
-                    results.append({
-                        'title': title_elem.get_text().strip(),
-                        'url': title_elem.get('href', ''),
-                        'description': snippet_elem.get_text().strip()
-                    })
+                    title = title_elem.get_text().strip()
+                    snippet = snippet_elem.get_text().strip()
+                    results.append(f"{title}: {snippet}")
             
-            return {'results': results} if results else {}
+            return " ".join(results) if results else ""
             
         except Exception as e:
-            print(f"DDG HTML scraping error: {e}")
-            return {}
-
-    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 = []
-        if title:
-            content_parts.append(title)
-        if description:
-            content_parts.append(description)
-        
-        full_content = ". ".join(content_parts)
-        
-        # 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
-        
-        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 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 _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
-        
-        answer = f"**According to web sources:** {relevant_sentence}"
-        
-        if len(sentences) > 1:
-            additional_info = '. '.join(sentences[1:3])
-            answer += f" {additional_info}."
-        
-        return answer
+            print(f"DuckDuckGo search error: {e}")
+            return ""
 
-    def _format_current_events_answer(self, question: str, content: str, source: str) -> str:
-        """Format current events answers"""
-        sentences = content.split('. ')
-        
-        answer = f"**Latest information:** {content[:400]}"
-        if len(content) > 400:
-            answer += "..."
+    def _get_weather_info(self, query):
+        """Get weather information from free sources"""
+        try:
+            # Extract location from query
+            location = self._extract_location(query)
+            if not location:
+                location = "New York"  # Default location
             
-        return answer
-
-    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('. ')
-        
-        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)
-        
-        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 answer
-
-    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)
-        
-        # 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())
-        
-        answer_parts = []
-        if location:
-            answer_parts.append(f"**Weather for {location}:**")
-        
-        if temp_match:
-            answer_parts.append(f"Temperature around {temp_match.group(1)}°F")
-        
-        if condition_match:
-            answer_parts.append(f"Conditions: {condition_match.group(1).title()}")
+            # Use free weather API
+            url = f"http://wttr.in/{urllib.parse.quote(location)}?format=%C+%t+%w+%h"
+            
+            response = requests.get(url, timeout=self.search_timeout)
+            if response.status_code == 200:
+                weather_data = response.text.strip()
+                return f"Weather in {location}: {weather_data}"
+                
+        except Exception as e:
+            print(f"Weather error: {e}")
         
-        if answer_parts:
-            return " ".join(answer_parts) + f"\n*Source: {source}*" if source else ""
-        else:
-            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 "")
+        return ""
 
-    def _extract_location(self, text: str) -> str:
-        """Extract location from text (simple version)"""
-        # Common city/country names
+    def _extract_location(self, text):
+        """Extract location from text"""
         locations = {
             'new york', 'london', 'paris', 'tokyo', 'berlin', 'sydney', 'toronto',
             'mumbai', 'beijing', 'moscow', 'dubai', 'rome', 'madrid', 'amsterdam',
@@ -356,15 +254,115 @@ class WebEnhancedBot:
         text_lower = text.lower()
         for location in locations:
             if location in text_lower:
-                return location.title()
+                return location
+        return ""
+
+    def _create_web_answer(self, user_input, web_content, sources):
+        """Create answer using web content"""
+        if not web_content or not web_content.strip():
+            return "I searched but couldn't find current information about that. Could you try rephrasing your question?"
+        
+        # Clean and format the content
+        sentences = re.split(r'[.!?]+', web_content)
+        meaningful_sentences = [s.strip() for s in sentences if len(s.strip()) > 10]
+        
+        if not meaningful_sentences:
+            return "I found some information but couldn't extract a clear answer. Try asking more specifically."
+        
+        # Use the most relevant sentences
+        answer_sentences = meaningful_sentences[:3]
+        answer = ". ".join(answer_sentences)
+        
+        # Ensure the answer ends with proper punctuation
+        if not answer.endswith(('.', '!', '?')):
+            answer += "."
+        
+        # Add source attribution if available
+        if sources:
+            source_text = ", ".join(sources)
+            answer += f"\n\nSources: {source_text}"
+        
+        return answer
+
+    def _get_factual_response(self, user_input):
+        """Provide factual responses without web search"""
+        input_lower = user_input.lower()
+        
+        # Time and date responses
+        if any(word in input_lower for word in ['time', 'clock', 'hour']):
+            current_time = datetime.now().strftime("%I:%M %p")
+            return f"The current time is {current_time}."
+            
+        if any(word in input_lower for word in ['date', 'today', 'day month']):
+            current_date = date.today().strftime("%A, %B %d, %Y")
+            return f"Today is {current_date}."
+            
+        if any(word in input_lower for word in ['day of week', 'what day']):
+            current_day = date.today().strftime("%A")
+            return f"Today is {current_day}."
+        
+        # Math calculations
+        math_result = self._solve_math(user_input)
+        if math_result:
+            return math_result
+            
+        # About the bot
+        if any(word in input_lower for word in ['your name', 'who are you']):
+            return "I'm Phoenix AI, a completely free chatbot with web search capabilities!"
+            
+        if any(word in input_lower for word in ['what can you do', 'capabilities']):
+            return "I can: Answer questions, search the web for free, do math, tell time/date, and learn from our conversations!"
+            
+        if any(word in input_lower for word in ['help', 'what can you help with']):
+            return "I can help you with: current news, weather information, factual questions, calculations, and general conversation. I learn from our chats too!"
         
         return ""
 
-    def _get_learned_response(self, user_input: str) -> str:
-        """Get response from learned patterns"""
-        context = self._analyze_input(user_input)
+    def _solve_math(self, user_input):
+        """Solve mathematical expressions"""
+        try:
+            # Simple arithmetic
+            if re.search(r'\d+\s*[\+\-\*\/]\s*\d+', user_input):
+                numbers = re.findall(r'\d+', user_input)
+                if len(numbers) >= 2:
+                    a, b = int(numbers[0]), int(numbers[1])
+                    
+                    if '+' in user_input:
+                        return f"{a} + {b} = {a + b}"
+                    elif '-' in user_input:
+                        return f"{a} - {b} = {a - b}"
+                    elif '*' in user_input or '×' in user_input:
+                        return f"{a} × {b} = {a * b}"
+                    elif '/' in user_input or '÷' in user_input:
+                        if b == 0:
+                            return "I cannot divide by zero - that's mathematically undefined!"
+                        result = a / b
+                        return f"{a} ÷ {b} = {result:.2f}"
+            
+            # Square roots
+            sqrt_match = re.search(r'sqrt\(?(\d+)\)?', user_input)
+            if sqrt_match:
+                num = int(sqrt_match.group(1))
+                if num < 0:
+                    return "I cannot calculate square roots of negative numbers!"
+                result = math.sqrt(num)
+                return f"√{num} = {result:.2f}"
+            
+            # Powers
+            power_match = re.search(r'(\d+)\s*\^\s*(\d+)', user_input)
+            if power_match:
+                base, exponent = int(power_match.group(1)), int(power_match.group(2))
+                result = base ** exponent
+                return f"{base}^{exponent} = {result}"
+                
+        except Exception as e:
+            print(f"Math solving error: {e}")
         
-        # Try learned patterns first
+        return ""
+
+    def _get_learned_response(self, user_input):
+        """Get response from learned patterns or generate contextual response"""
+        # Find similar patterns
         similar_patterns = self._find_similar_patterns(user_input)
         if similar_patterns:
             best_pattern = max(similar_patterns, key=lambda x: x[1]['score'])
@@ -372,106 +370,116 @@ class WebEnhancedBot:
                 return best_pattern[1]['response']
         
         # Generate contextual response
-        return self._generate_contextual_response(user_input, context)
+        return self._generate_contextual_response(user_input)
 
-    def _generate_contextual_response(self, user_input: str, context: dict) -> str:
-        """Generate contextual response when no web results"""
+    def _find_similar_patterns(self, text):
+        """Find similar learned patterns"""
+        similar = []
+        text_words = set(text.lower().split())
+        
+        for pattern, data in self.learned_patterns.items():
+            pattern_words = set(pattern.lower().split())
+            common_words = text_words.intersection(pattern_words)
+            if common_words:
+                similarity = len(common_words) / len(text_words.union(pattern_words))
+                if similarity > 0.3:
+                    similar.append((pattern, data))
+                
+        return similar
+
+    def _generate_contextual_response(self, user_input):
+        """Generate contextual response when no specific pattern matches"""
+        context = self._analyze_input(user_input)
+        
         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, "
+                "That's an interesting question. Based on what I know, ",
+                "I appreciate your question. From my understanding, ",
+                "That's a great question. I've been learning that ",
             ]
-            base = random.choice(responses)
+            base_response = random.choice(responses)
             
             if context['topics']:
-                return base + f"{random.choice(context['topics'])}. Could you tell me more about what specifically interests you?"
+                topic = random.choice(context['topics'])
+                return base_response + f"{topic} is quite fascinating. What specifically would you like to know?"
             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 base_response + "this topic has many interesting aspects. Could you tell me more about what you're curious about?"
+        
+        # Conversational responses for statements
+        conversational_responses = [
+            "I understand. Tell me more about that.",
+            "That's interesting. What are your thoughts on this?",
+            "I appreciate you sharing that. How do you feel about it?",
+            "That's fascinating. I'm learning from our conversation.",
+            "I see. Could you elaborate on that?",
         ]
-        return random.choice(conversational)
+        
+        return random.choice(conversational_responses)
 
-    def _analyze_input(self, text: str) -> dict:
-        """Analyze user input"""
+    def _analyze_input(self, text):
+        """Analyze user input for context"""
+        words = text.split()
+        
         return {
-            'words': text.split(),
+            'words': words,
             'topics': self._extract_topics(text),
             'has_question': '?' in text,
-            'sentiment': self._analyze_sentiment(text)
+            'sentiment': self._analyze_sentiment(text),
+            'word_count': len(words)
         }
 
-    def _extract_topics(self, text: str) -> list:
+    def _extract_topics(self, text):
         """Extract topics from text"""
         topics = []
-        topic_keywords = {
-            '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()
+        
+        topic_categories = {
+            'technology': ['tech', 'computer', 'ai', 'software', 'code', 'internet', 'programming'],
+            'science': ['science', 'research', 'discover', 'physics', 'biology', 'chemistry'],
+            'sports': ['sports', 'game', 'team', 'player', 'score', 'match', 'tournament'],
+            'entertainment': ['movie', 'music', 'show', 'celebrity', 'film', 'song'],
+            'health': ['health', 'medical', 'fitness', 'diet', 'exercise', 'nutrition']
         }
         
-        text_lower = text.lower()
-        for topic, keywords in topic_keywords.items():
+        for topic, keywords in topic_categories.items():
             if any(keyword in text_lower for keyword in keywords):
                 topics.append(topic)
                 
         return topics
 
-    def _analyze_sentiment(self, text: str) -> str:
+    def _analyze_sentiment(self, text):
         """Basic sentiment analysis"""
-        positive = ['love', 'like', 'good', 'great', 'awesome', 'happy']
-        negative = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry']
+        positive_words = ['love', 'like', 'good', 'great', 'awesome', 'happy', 'excited', 'amazing']
+        negative_words = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry', 'upset']
         
-        pos_count = sum(1 for word in positive if word in text)
-        neg_count = sum(1 for word in negative if word in text)
+        text_lower = text.lower()
+        positive_count = sum(1 for word in positive_words if word in text_lower)
+        negative_count = sum(1 for word in negative_words if word in text_lower)
         
-        if pos_count > neg_count:
+        if positive_count > negative_count:
             return "positive"
-        elif neg_count > pos_count:
+        elif negative_count > positive_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))
-                
-        return similar
-
-    def _store_interaction(self, user_input: str, response: str, reward: float, web_context: dict):
+    def _store_interaction(self, user_input, response, reward, sources):
         """Store interaction in memory"""
         interaction = {
             'input': user_input,
             'response': response,
             'reward': reward,
-            'web_context': web_context,
+            'sources': sources,
             '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):
+    def _update_learning(self, user_input, response, reward):
         """Update learning from interaction"""
-        # Extract key phrases for pattern learning
-        words = [w for w in user_input.split() if len(w) > 3][:4]
+        # Extract key phrases from input for pattern learning
+        words = [word for word in user_input.split() if len(word) > 3][:4]
         if words:
             pattern = ' '.join(words)
             
@@ -482,58 +490,78 @@ class WebEnhancedBot:
                     'count': 1
                 }
             else:
-                old = self.learned_patterns[pattern]
-                new_score = (old['score'] * old['count'] + reward) / (old['count'] + 1)
+                old_data = self.learned_patterns[pattern]
+                new_score = (old_data['score'] * old_data['count'] + reward) / (old_data['count'] + 1)
                 self.learned_patterns[pattern]['score'] = new_score
                 self.learned_patterns[pattern]['count'] += 1
         
+        # Store in response memory
+        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
+            }
+        else:
+            memory = self.response_memory[response_hash]
+            memory['total_score'] += reward
+            memory['count'] += 1
+            memory['avg_score'] = memory['total_score'] / memory['count']
+        
         # Store reward
         self.reward_history.append(reward)
         
-        # Periodic save
+        # Save state periodically
         if len(self.conversation_memory) % 10 == 0:
             self.save_state()
 
-    def learn_from_feedback(self, user_input: str, reward: float):
-        """Learn from explicit feedback"""
+    def learn_from_feedback(self, user_input, reward):
+        """Learn from explicit user feedback"""
         if self.conversation_memory:
-            recent = self.conversation_memory[-1]
-            recent['reward'] = reward
-            self._update_learning(recent['input'], recent['response'], reward)
+            # Update the most recent interaction
+            recent_interaction = self.conversation_memory[-1]
+            recent_interaction['reward'] = reward
+            self._update_learning(recent_interaction['input'], recent_interaction['response'], reward)
 
-    def get_learning_stats(self) -> dict:
+    def get_learning_stats(self):
         """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),
+            'avg_score': float(np.mean(recent_rewards)),
             'recent_rewards': len([r for r in recent_rewards if r > 0.7])
         }
 
     def save_state(self):
-        """Save learning state"""
+        """Save learning state to file"""
         try:
             state = {
                 'learned_patterns': self.learned_patterns,
+                'response_memory': self.response_memory,
                 'conversation_memory': list(self.conversation_memory),
-                'reward_history': list(self.reward_history)
+                'reward_history': list(self.reward_history),
+                'last_saved': datetime.now().isoformat()
             }
             with open(self.state_file, 'w') as f:
                 json.dump(state, f, indent=2)
         except Exception as e:
-            print(f"Save error: {e}")
+            print(f"Error saving state: {e}")
 
     def load_state(self):
-        """Load learning state"""
+        """Load learning state from file"""
         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.conversation_memory = deque(state.get('conversation_memory', []), maxlen=150)
-                self.reward_history = deque(state.get('reward_history', []), maxlen=200)
-        except:
-            pass
+                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)
+                print(f"Loaded state with {len(self.learned_patterns)} patterns")
+        except Exception as e:
+            print(f"Error loading state: {e}")