Fix python-dotenv compatibility issue and add advanced conversation model

app.py

@@ -5,12 +5,18 @@ This is the main entry point for the Spaces deployment.
 """
 
 import os
-from dotenv import load_dotenv
 from flask import Flask, render_template, request, jsonify
 from src.main import MemoryAI
 
-# Load environment variables
-load_dotenv()
+# Load environment variables (with fallback if dotenv not available)
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    print("⚠️  python-dotenv not available, using environment variables directly")
+    # Set default values if .env not loaded
+    if not os.getenv("MODEL_NAME"):
+        os.environ["MODEL_NAME"] = "microsoft/DialoGPT-small"
 
 # Initialize Flask app
 app = Flask(__name__)
@@ -48,26 +54,47 @@ def chat():
     """Get AI response to user input."""
     data = request.json
     user_input = data.get('message', '')
+    conversation_history = data.get('history', [])
     
     if not user_input.strip():
         return jsonify({'error': 'Empty message'}), 400
     
-    # Add user input to memories
-    ai.add_memory(f"User: {user_input}")
+    # Generate AI response with conversation history
+    response = ai.generate_response(user_input, conversation_history=conversation_history)
     
-    # Get recent memories for context
-    recent_context = "\n".join(ai.get_recent_memories(3))
-    full_prompt = f"{recent_context}\n\nUser: {user_input}\nAI:"
-    
-    # Generate AI response
-    response = ai.generate_response(full_prompt)
+    return jsonify({
+        'response': response,
+        'memory_count': len(ai.memories),
+        'conversation_stats': ai.get_conversation_stats() if hasattr(ai, 'get_conversation_stats') else {}
+    })
+
+@app.route('/api/summary', methods=['GET'])
+def get_summary():
+    """Get conversation summary."""
+    summary = ai.get_conversation_summary()
+    return jsonify({'summary': summary})
+
+@app.route('/api/similar', methods=['POST'])
+def find_similar():
+    """Find similar memories."""
+    data = request.json
+    query = data.get('query', '')
+    top_k = data.get('top_k', 3)
     
-    # Add AI response to memories
-    ai.add_memory(f"AI: {response}")
+    if not query.strip():
+        return jsonify({'error': 'Empty query'}), 400
     
+    similar = ai.find_similar_memories(query, top_k)
     return jsonify({
-        'response': response,
-        'memory_count': len(ai.memories)
+        'similar_memories': [{'text': text, 'similarity': float(score)} for text, score in similar],
+        'query': query
+    })
+
+@app.route('/api/reset', methods=['POST'])
+def reset_conversation():
+    """Reset conversation state."""
+    ai.reset_conversation()
+    return jsonify({'status': 'success', 'message': 'Conversation reset'})
     })
 
 @app.route('/api/save', methods=['POST'])

spaces_requirements.txt

@@ -7,6 +7,12 @@ flask==3.1.2
 python-dotenv==1.0.1
 datasets==4.4.2
 accelerate==1.12.0
+sentence-transformers==2.2.2
+scikit-learn==1.5.0
 blinker==1.9.0
 itsdangerous==2.2.0
-werkzeug==3.1.5
+werkzeug==3.1.5
+# Ensure proper Flask dependencies
+click==8.1.7
+jinja2==3.1.4
+markupsafe==2.1.5

src/conversation_model.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+"""
+Advanced Conversation Model for MemoryAI
+
+This module provides enhanced conversation capabilities with:
+- Multi-turn dialog management
+- Context-aware response generation
+- Personality and style control
+- Emotion detection and response
+- Topic tracking and continuity
+"""
+
+import os
+import re
+import random
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, pipeline
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import torch
+
+# Check for GPU availability
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+class ConversationModel:
+    """
+    Advanced conversation model with memory and context awareness.
+    
+    Features:
+    - Multi-turn conversation handling
+    - Context-aware responses
+    - Emotion detection
+    - Topic tracking
+    - Personality control
+    """
+    
+    def __init__(self, model_name: str = "facebook/blenderbot-400M-distill", 
+                 embedding_model: str = "all-MiniLM-L6-v2"):
+        """
+        Initialize the conversation model.
+        
+        Args:
+            model_name: Hugging Face model name for conversation
+            embedding_model: Model for semantic embeddings
+        """
+        self.model_name = model_name
+        self.embedding_model_name = embedding_model
+        
+        # Load models
+        self.tokenizer = None
+        self.model = None
+        self.embedding_model = None
+        self.conversation_pipeline = None
+        
+        self.load_models()
+        
+        # Conversation state
+        self.conversation_history = []
+        self.current_topic = "general"
+        self.user_emotion = "neutral"
+        self.conversation_length = 0
+        
+        # Personality settings
+        self.personality = {
+            "friendliness": 0.8,
+            "humor": 0.6,
+            "formality": 0.3,
+            "verbosity": 0.7,
+            "curiosity": 0.9
+        }
+        
+        # Response enhancements
+        self.response_enhancers = {
+            "greetings": ["Hello!", "Hi there!", "Hey!", "Greetings!", "Nice to see you!"],
+            "goodbyes": ["Goodbye!", "See you later!", "Take care!", "Bye!", "Have a great day!"],
+            "agreements": ["Yes!", "Absolutely!", "I agree!", "Exactly!", "You're right!"],
+            "disagreements": ["I see your point, but...", "That's interesting, however...", 
+                            "I understand, but I think...", "That's a good perspective, but..."],
+            "questions": ["What do you think about that?", "Does that make sense?", 
+                         "How does that sound?", "What's your opinion?"]
+        }
+    
+    def load_models(self):
+        """Load the conversation and embedding models."""
+        try:
+            print(f"Loading conversation model: {self.model_name}")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name).to(device)
+            
+            # Create conversation pipeline
+            self.conversation_pipeline = pipeline(
+                "conversational",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+            
+            print(f"Loading embedding model: {self.embedding_model_name}")
+            self.embedding_model = SentenceTransformer(self.embedding_model_name)
+            
+            print("✅ Models loaded successfully!")
+            
+        except Exception as e:
+            print(f"❌ Error loading models: {e}")
+            # Fallback to simpler model
+            print("Falling back to basic conversation model...")
+            self.model_name = "microsoft/DialoGPT-small"
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForSeq2SeqLM.from_pretrained(self.model_name).to(device)
+            self.conversation_pipeline = pipeline(
+                "conversational",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+    
+    def detect_emotion(self, text: str) -> str:
+        """Detect emotion in user input."""
+        # Simple emotion detection based on keywords
+        text_lower = text.lower()
+        
+        happy_keywords = ["happy", "joy", "excited", "great", "awesome", "wonderful", "love"]
+        sad_keywords = ["sad", "unhappy", "depressed", "terrible", "awful", "hate"]
+        angry_keywords = ["angry", "mad", "furious", "annoyed", "frustrated"]
+        
+        if any(keyword in text_lower for keyword in happy_keywords):
+            return "happy"
+        elif any(keyword in text_lower for keyword in sad_keywords):
+            return "sad"
+        elif any(keyword in text_lower for keyword in angry_keywords):
+            return "angry"
+        else:
+            return "neutral"
+    
+    def detect_topic(self, text: str) -> str:
+        """Detect the topic of conversation."""
+        text_lower = text.lower()
+        
+        topic_keywords = {
+            "technology": ["tech", "computer", "software", "hardware", "ai", "machine learning"],
+            "sports": ["sports", "game", "football", "basketball", "soccer", "tennis"],
+            "movies": ["movie", "film", "cinema", "actor", "actress", "director"],
+            "music": ["music", "song", "band", "artist", "concert", "album"],
+            "travel": ["travel", "vacation", "trip", "hotel", "flight", "destination"],
+            "food": ["food", "restaurant", "cooking", "recipe", "cuisine", "dish"],
+            "work": ["work", "job", "career", "office", "meeting", "project"],
+            "personal": ["life", "family", "friend", "relationship", "feeling", "emotion"]
+        }
+        
+        for topic, keywords in topic_keywords.items():
+            if any(keyword in text_lower for keyword in keywords):
+                return topic
+                
+        return "general"
+    
+    def generate_response(self, user_input: str, conversation_history: List[Dict] = None) -> str:
+        """
+        Generate a response to user input with full conversation context.
+        
+        Args:
+            user_input: The user's message
+            conversation_history: Previous conversation turns
+            
+        Returns:
+            Generated response string
+        """
+        if conversation_history is None:
+            conversation_history = []
+            
+        # Update conversation state
+        self.user_emotion = self.detect_emotion(user_input)
+        self.current_topic = self.detect_topic(user_input)
+        self.conversation_length += 1
+        
+        # Add current input to history
+        conversation_history.append({"role": "user", "content": user_input})
+        
+        try:
+            # Generate response using the conversation model
+            response = self.conversation_pipeline(
+                conversation_history,
+                max_length=150,
+                temperature=0.7,
+                top_p=0.9,
+                repetition_penalty=1.2,
+                num_return_sequences=1,
+                do_sample=True  # Enable sampling for temperature/top_p to work
+            )
+            
+            # Handle different response formats
+            if isinstance(response, list) and len(response) > 0:
+                if 'generated_text' in response[0]:
+                    generated_text = response[0]['generated_text']
+                elif 'text' in response[0]:
+                    generated_text = response[0]['text']
+                else:
+                    # Try to get the first available text
+                    generated_text = str(response[0].get('generated_response', response[0].get('response', '')))
+            else:
+                generated_text = str(response)
+            
+            # Clean and enhance the response
+            enhanced_response = self.enhance_response(generated_text, user_input)
+            
+            # Add to conversation history
+            conversation_history.append({"role": "assistant", "content": enhanced_response})
+            
+            return enhanced_response
+            
+        except Exception as e:
+            print(f"Error generating response: {e}")
+            return self.get_fallback_response(user_input)
+    
+    def enhance_response(self, response: str, user_input: str) -> str:
+        """Enhance the generated response based on context and personality."""
+        # Clean up the response
+        response = self.clean_response(response)
+        
+        # Add personality traits
+        response = self.add_personality(response)
+        
+        # Make it more conversational
+        response = self.make_conversational(response, user_input)
+        
+        return response
+    
+    def clean_response(self, response: str) -> str:
+        """Clean up the generated response text."""
+        # Remove special tokens and cleanup
+        response = response.strip()
+        response = re.sub(r'\s+', ' ', response)
+        response = re.sub(r'[""\'\']', '', response)
+        
+        # Capitalize first letter and add period if missing
+        if response and response[0].islower():
+            response = response[0].upper() + response[1:]
+            
+        if response and response[-1] not in ['.', '!', '?']:
+            response += '.'
+            
+        return response
+    
+    def add_personality(self, response: str) -> str:
+        """Add personality traits to the response."""
+        # Add friendliness
+        if self.personality["friendliness"] > 0.7:
+            friendly_phrases = ["by the way", "I think", "in my opinion", 
+                              "that's interesting", "I'd say"]
+            if random.random() < 0.3:  # 30% chance to add friendly phrase
+                phrase = random.choice(friendly_phrases)
+                response = f"{phrase}, {response}"
+        
+        # Add humor if appropriate
+        if self.personality["humor"] > 0.5 and self.user_emotion in ["happy", "neutral"]:
+            if random.random() < 0.2:  # 20% chance to add humor
+                humor_tags = ["😄", "😊", "🤣", "😆"]
+                response += " " + random.choice(humor_tags)
+        
+        return response
+    
+    def make_conversational(self, response: str, user_input: str) -> str:
+        """Make the response more conversational and context-aware."""
+        # Add context references
+        if self.conversation_length > 1:
+            context_phrases = [
+                "As we were discussing",
+                "Regarding what you mentioned",
+                "Building on that idea",
+                "That reminds me"
+            ]
+            if random.random() < 0.25:
+                response = f"{random.choice(context_phrases)}, {response}"
+        
+        # Add follow-up questions
+        if random.random() < 0.4:  # 40% chance to add a follow-up
+            follow_ups = [
+                "What do you think about that?",
+                "Does that make sense?",
+                "How does that sound to you?",
+                "Would you like me to elaborate?"
+            ]
+            response += " " + random.choice(follow_ups)
+        
+        return response
+    
+    def get_fallback_response(self, user_input: str) -> str:
+        """Get a fallback response when model generation fails."""
+        fallback_responses = [
+            "That's an interesting question! Let me think about that...",
+            "I'm not sure I understand completely. Could you elaborate?",
+            "That's a complex topic. What specifically would you like to know?",
+            "I'd love to help with that. Can you provide more details?",
+            "That's fascinating! Tell me more about what you're thinking."
+        ]
+        
+        return random.choice(fallback_responses)
+    
+    def get_conversation_summary(self) -> str:
+        """Get a summary of the current conversation."""
+        if not self.conversation_history:
+            return "No conversation history yet."
+            
+        summary = f"Conversation Summary:\n"
+        summary += f"- Topic: {self.current_topic}\n"
+        summary += f"- User Emotion: {self.user_emotion}\n"
+        summary += f"- Duration: {self.conversation_length} turns\n"
+        summary += f"- Main Points:\n"
+        
+        # Extract key points from conversation
+        for i, turn in enumerate(self.conversation_history):
+            role = "You" if turn["role"] == "user" else "AI"
+            summary += f"  {i+1}. {role}: {turn['content'][:50]}...\n"
+            
+        return summary
+    
+    def find_similar_conversations(self, query: str, top_k: int = 3) -> List[Tuple[str, float]]:
+        """Find similar conversations from history using semantic search."""
+        if not self.conversation_history or not self.embedding_model:
+            return []
+            
+        try:
+            # Get embedding for the query
+            query_embedding = self.embedding_model.encode([query])
+            
+            # Get embeddings for conversation history
+            history_texts = [turn["content"] for turn in self.conversation_history if turn["role"] == "user"]
+            history_embeddings = self.embedding_model.encode(history_texts)
+            
+            # Calculate similarities
+            similarities = cosine_similarity(query_embedding, history_embeddings)[0]
+            
+            # Get top k similar conversations
+            top_indices = np.argsort(similarities)[-top_k:][::-1]
+            
+            similar_conversations = []
+            for idx in top_indices:
+                similar_conversations.append((history_texts[idx], similarities[idx]))
+                
+            return similar_conversations
+            
+        except Exception as e:
+            print(f"Error in semantic search: {e}")
+            return []
+    
+    def reset_conversation(self):
+        """Reset the conversation state."""
+        self.conversation_history = []
+        self.current_topic = "general"
+        self.user_emotion = "neutral"
+        self.conversation_length = 0
+        print("Conversation reset successfully!")
+    
+    def get_conversation_stats(self) -> Dict:
+        """Get statistics about the current conversation."""
+        return {
+            "length": self.conversation_length,
+            "current_topic": self.current_topic,
+            "user_emotion": self.user_emotion,
+            "personality": self.personality,
+            "model": self.model_name
+        }
+
+# Example usage and testing
+if __name__ == "__main__":
+    print("🤖 Advanced Conversation Model - Testing")
+    print("=" * 50)
+    
+    # Initialize the conversation model
+    conv_model = ConversationModel()
+    
+    # Test conversation
+    print("Starting test conversation...")
+    
+    conversation = []
+    
+    # Test inputs
+    test_inputs = [
+        "Hello! How are you doing today?",
+        "I'm really excited about the new AI technologies!",
+        "What do you think about machine learning?",
+        "Can you tell me more about neural networks?",
+        "That was very helpful, thank you!"
+    ]
+    
+    for user_input in test_inputs:
+        print(f"\n👤 User: {user_input}")
+        response = conv_model.generate_response(user_input, conversation)
+        print(f"🤖 AI: {response}")
+        
+        # Show conversation stats
+        stats = conv_model.get_conversation_stats()
+        print(f"📊 Topic: {stats['current_topic']} | Emotion: {stats['user_emotion']}")
+    
+    # Show conversation summary
+    print(f"\n{conv_model.get_conversation_summary()}")
+    
+    # Test semantic search
+    print("\n🔍 Testing semantic search...")
+    similar = conv_model.find_similar_conversations("AI technologies", top_k=2)
+    print("Similar conversations found:")
+    for text, score in similar:
+        print(f"  - '{text[:30]}...' (similarity: {score:.3f})")
+    
+    print("\n✅ Conversation model testing complete!")

src/main.py

@@ -8,12 +8,23 @@ import os
 from dotenv import load_dotenv
 from transformers import AutoModelForCausalLM, AutoTokenizer
 import torch
+from typing import List, Dict, Optional
 
-# Load environment variables
-load_dotenv()
+# Import our advanced conversation model
+try:
+    from src.conversation_model import ConversationModel
+except ImportError:
+    # Fallback import for direct execution
+    from conversation_model import ConversationModel
+
+# Load environment variables (with fallback if dotenv not available)
+try:
+    load_dotenv()
+except ImportError:
+    print("⚠️  python-dotenv not available, using default values")
 
 class MemoryAI:
-    def __init__(self):
+    def __init__(self, use_advanced_model: bool = True):
         """Initialize the AI model and memory system."""
         self.model_name = os.getenv("MODEL_NAME", "gpt2")
         self.max_memory = int(os.getenv("MAX_MEMORY_ENTRIES", 100))
@@ -29,19 +40,33 @@ class MemoryAI:
         # Initialize memory storage
         self.memories = []
         
-        # Load model and tokenizer
-        print(f"Loading {self.model_name} model...")
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
+        # Initialize conversation model
+        self.use_advanced_model = use_advanced_model
+        self.conversation_model = None
         
-        # Move model to GPU if available
-        if torch.cuda.is_available():
-            self.model = self.model.to('cuda')
-            print("Using CUDA (GPU acceleration)")
-        else:
-            print("Using CPU")
+        if use_advanced_model:
+            try:
+                print("Loading advanced conversation model...")
+                self.conversation_model = ConversationModel()
+                print("✅ Advanced conversation model loaded!")
+            except Exception as e:
+                print(f"❌ Error loading advanced model: {e}")
+                print("Falling back to basic model...")
+                self.use_advanced_model = False
+        
+        # Load basic model as fallback
+        if not self.use_advanced_model:
+            print(f"Loading basic {self.model_name} model...")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
+            
+            # Move model to GPU if available
+            if torch.cuda.is_available():
+                self.model = self.model.to('cuda')
+                print("Using CUDA (GPU acceleration)")
+            else:
+                print("Using CPU")
         
-        print(f"Initialized {self.model_name} model")
         print(f"Memory capacity: {self.max_memory} entries")
         print(f"Generation params - Temp: {self.temperature}, Max tokens: {self.max_new_tokens}")
     
@@ -53,8 +78,33 @@ class MemoryAI:
         self.memories.append(memory_text)
         print(f"Memory added. Total memories: {len(self.memories)}")
     
-    def generate_response(self, prompt, max_new_tokens=80):
+    def generate_response(self, prompt, max_new_tokens=80, conversation_history=None):
         """Generate a response using the AI model with improved quality."""
+        # Use advanced conversation model if available
+        if self.use_advanced_model and self.conversation_model:
+            try:
+                # Convert memory to conversation history format
+                conv_history = []
+                if conversation_history:
+                    for entry in conversation_history:
+                        conv_history.append({"role": entry.get("role", "user"), 
+                                          "content": entry.get("content", entry.get("text", ""))})
+                
+                # Generate response using advanced model
+                response = self.conversation_model.generate_response(prompt, conv_history)
+                
+                # Add to memories
+                self.add_memory(f"User: {prompt}")
+                self.add_memory(f"AI: {response}")
+                
+                return response
+                
+            except Exception as e:
+                print(f"Advanced model error: {e}")
+                # Fallback to basic model
+                pass
+        
+        # Fallback to basic model
         # Improved prompt engineering for conversational AI
         if "microsoft/DialoGPT" in self.model_name:
             # DialoGPT uses a different format
@@ -66,7 +116,7 @@ class MemoryAI:
         inputs = self.tokenizer(improved_prompt, return_tensors="pt")
         
         # Move inputs to same device as model
-        if next(self.model.parameters()).is_cuda:
+        if hasattr(self, 'model') and next(self.model.parameters()).is_cuda:
             inputs = {k: v.to('cuda') for k, v in inputs.items()}
         
         # Generate with better parameters
@@ -151,44 +201,62 @@ class MemoryAI:
     
     def converse(self):
         """Start a conversation loop with the AI."""
-        print("Starting conversation... Type 'quit' to exit.")
+        print("🤖 MemoryAI - Advanced Conversation Mode")
+        print("Type 'quit' to exit.")
         print("Type '!memories' to see recent memories, '!clear' to clear memories")
+        print("Type '!summary' for conversation summary, '!reset' to reset conversation")
+        print("=" * 60)
+        
+        # Initialize conversation history for advanced model
+        conversation_history = []
         
         while True:
-            user_input = input("You: ")
+            user_input = input("👤 You: ")
             
             if user_input.lower() == 'quit':
+                print("🤖 AI: Goodbye! Have a great day!")
                 break
             
             # Handle special commands
             if user_input.lower() == '!memories':
                 recent_memories = self.get_recent_memories()
-                print("Recent memories:")
+                print("📚 Recent memories:")
                 for i, memory in enumerate(recent_memories, 1):
                     print(f"  {i}. {memory}")
                 continue
             
             if user_input.lower() == '!clear':
                 self.clear_memories()
+                print("🗑️  Memories cleared!")
                 continue
             
-            # Add user input to memories
-            self.add_memory(f"User: {user_input}")
-            
-            # Get recent memories for context
-            recent_context = "\n".join(self.get_recent_memories(3))
-            full_prompt = f"{recent_context}\n\nUser: {user_input}\nAI:"
+            if user_input.lower() == '!summary' and self.use_advanced_model:
+                summary = self.get_conversation_summary()
+                print(f"📊 {summary}")
+                continue
             
-            # Generate AI response
-            response = self.generate_response(full_prompt)
-            print(f"AI: {response}")
+            if user_input.lower() == '!reset':
+                self.reset_conversation()
+                conversation_history = []
+                continue
             
-            # Add AI response to memories
-            self.add_memory(f"AI: {response}")
+            if user_input.strip():
+                # Generate response with conversation history
+                response = self.generate_response(user_input, conversation_history=conversation_history)
+                print(f"🤖 AI: {response}")
+                
+                # Update conversation history
+                conversation_history.append({"role": "user", "content": user_input})
+                conversation_history.append({"role": "assistant", "content": response})
+                
+                # Show conversation stats if using advanced model
+                if self.use_advanced_model and self.conversation_model:
+                    stats = self.conversation_model.get_conversation_stats()
+                    print(f"📊 Topic: {stats['current_topic']} | Emotion: {stats['user_emotion']}")
     
     def get_available_models(self):
         """Get a list of commonly available models."""
-        return [
+        models = [
             "gpt2",
             "distilgpt2",
             "gpt2-medium",
@@ -198,6 +266,36 @@ class MemoryAI:
             "microsoft/DialoGPT-small",
             "microsoft/DialoGPT-medium"
         ]
+        
+        # Add advanced conversation models
+        if self.use_advanced_model:
+            models.extend([
+                "facebook/blenderbot-400M-distill",
+                "facebook/blenderbot-1B-distill",
+                "microsoft/DialoGPT-large"
+            ])
+        
+        return models
+    
+    def get_conversation_summary(self) -> str:
+        """Get a summary of the current conversation."""
+        if not self.use_advanced_model or not self.conversation_model:
+            return "Conversation summary available only with advanced model."
+        
+        return self.conversation_model.get_conversation_summary()
+    
+    def find_similar_memories(self, query: str, top_k: int = 3) -> list:
+        """Find memories similar to the query using semantic search."""
+        if not self.use_advanced_model or not self.conversation_model:
+            return []
+        
+        return self.conversation_model.find_similar_conversations(query, top_k)
+    
+    def reset_conversation(self):
+        """Reset the conversation state."""
+        if self.use_advanced_model and self.conversation_model:
+            self.conversation_model.reset_conversation()
+        print("Conversation reset successfully!")
     
     def save_memories(self):
         """Save memories to a file."""