Initial commit: Memory Chat application

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

MANUAL_UPLOAD.md

@@ -0,0 +1,112 @@
+# Manual Upload to Hugging Face Spaces
+
+## Quick Manual Upload Process
+
+### Step 1: Create Your Space
+
+1. **Go to**: https://huggingface.co/spaces
+2. **Sign in** to your Hugging Face account
+3. **Click "Create new Space"** (top right)
+4. **Set Space Name**: Choose a name (e.g., `your-username/memory-chat`)
+5. **Select Type**: Choose "Gradio"
+6. **Set Visibility**: Select "Public"
+7. **Click "Create Space"**
+
+### Step 2: Upload Files
+
+In your new Space:
+
+1. **Click "Files and versions"** tab
+2. **Click "Upload file"**
+3. **Upload these files**:
+
+| File | Description |
+|------|-------------|
+| `app.py` | Main application |
+| `memory_manager.py` | Memory storage system |
+| `chat_interface.py` | Hugging Face integration |
+| `config.py` | Configuration settings |
+| `requirements.txt` | Python dependencies |
+| `README.md` | Documentation |
+
+4. **For each file**:
+   - Click "Upload file"
+   - Select the file from your computer
+   - Add commit message: "Add [filename]"
+   - Click "Commit changes"
+
+### Step 3: Wait for Build
+
+1. **Go to "Logs" tab** to monitor the build
+2. **Wait 3-5 minutes** for the first build
+3. **Check for any errors** in the logs
+
+### Step 4: Access Your Space
+
+Once built, your Space will be live at:
+```
+https://huggingface.co/spaces/your-username/memory-chat
+```
+
+## File Contents Summary
+
+### `app.py` (10KB)
+- Main application optimized for HF Spaces
+- Memory management and chat interface
+- Gradio UI with multiple tabs
+
+### `memory_manager.py` (7.7KB)
+- Vector embeddings for memory storage
+- FAISS indexing for fast retrieval
+- Persistent JSON storage
+
+### `chat_interface.py` (3.8KB)
+- Hugging Face model integration
+- DialoGPT model loading
+- Response generation
+
+### `config.py` (1.2KB)
+- Application configuration
+- Model settings and memory parameters
+
+### `requirements.txt` (238B)
+- Python dependencies for HF Spaces
+- Optimized for Spaces environment
+
+### `README.md` (1.3KB)
+- User documentation
+- Usage instructions
+
+## Troubleshooting
+
+### Build Failures
+- Check "Logs" tab for error messages
+- Ensure all files are uploaded correctly
+- Verify requirements.txt format
+
+### Model Loading Issues
+- First-time loading may be slow (30-60 seconds)
+- Application has fallback modes
+- Check internet connection
+
+### Memory Issues
+- Ensure `app.py` is uploaded (not `space_app.py`)
+- Check file permissions
+- Verify `/tmp/memories` directory access
+
+## Success Indicators
+
+✅ **Build Success**: "Build completed successfully" in logs
+✅ **App Running**: "App is running on port 7860"
+✅ **Space Live**: URL accessible and interactive
+
+## After Deployment
+
+1. **Test the chat functionality**
+2. **Verify memory recording**
+3. **Share your Space URL**
+4. **Monitor usage in dashboard**
+
+---
+
+**Your Memory Chat application is ready for upload!** 🚀

QUICK_DEPLOY.md

@@ -0,0 +1,74 @@
+# 🚀 SUPER QUICK DEPLOYMENT GUIDE
+
+## One-Click Deployment Process
+
+### Step 1: Create Space (2 minutes)
+Click this link: https://huggingface.co/spaces/new
+
+**Fill in these exact details:**
+- **Space name**: `memory-chat` (or any name you like)
+- **Space type**: `Gradio`
+- **Visibility**: `Public`
+- **Click**: "Create Space"
+
+### Step 2: Upload Files (3 minutes)
+
+**Click "Upload file" and upload these files in order:**
+
+1. **app.py** → Add commit: "Add main application"
+2. **memory_manager.py** → Add commit: "Add memory system"
+3. **chat_interface.py** → Add commit: "Add chat interface"
+4. **config.py** → Add commit: "Add configuration"
+5. **requirements.txt** → Add commit: "Add dependencies"
+6. **README.md** → Add commit: "Add documentation"
+
+### Step 3: Wait & Watch (3-5 minutes)
+
+**Go to "Logs" tab and watch the build:**
+- Should say "Build completed successfully"
+- If errors, check file uploads
+
+### Step 4: Enjoy! (Instant)
+
+**Your Space URL:**
+```
+https://huggingface.co/spaces/YOUR_USERNAME/memory-chat
+```
+
+## 🎯 What You'll Get
+
+✅ **Live AI Chat** with memory recording
+✅ **Beautiful Interface** with 4 tabs
+✅ **Persistent Storage** for memories
+✅ **Multi-user Support** for sharing
+
+## 📱 Direct Links
+
+- **Create Space**: https://huggingface.co/spaces/new
+- **Your Spaces**: https://huggingface.co/spaces/YOUR_USERNAME
+- **Space Settings**: Click "Settings" in your Space
+
+## 🆘 If You Get Stuck
+
+**Common Issues:**
+1. **Build fails**: Re-upload files, check "Logs" tab
+2. **App not loading**: Wait 2 minutes, refresh page
+3. **Memory not working**: Ensure app.py uploaded (not space_app.py)
+
+**Quick Fix Commands:**
+```bash
+# If build fails, re-upload all files:
+app.py → "Fix main app"
+memory_manager.py → "Fix memory system"
+chat_interface.py → "Fix chat interface"
+config.py → "Fix config"
+requirements.txt → "Fix dependencies"
+README.md → "Fix docs"
+```
+
+---
+
+**Total Time: 10 minutes**
+**Your Space will be LIVE and ready to use!**
+
+**Questions?** Just ask and I'll help you through any step! 🚀

README.md

@@ -0,0 +1,53 @@
+# Hugging Face Memory Chat
+
+A conversational AI application built with Hugging Face models that records and remembers user memories.
+
+## Features
+
+- 🤖 Hugging Face model integration
+- 💾 Memory storage and retrieval
+- 💬 Simple conversational interface
+- 🔐 Secure memory management
+
+## Setup
+
+1. Install requirements:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Set up Hugging Face API token:
+   ```bash
+   export HUGGINGFACE_API_TOKEN=your_token_here
+   ```
+
+3. Run the application:
+   ```bash
+   python app.py
+   ```
+
+## Usage
+
+The application provides a simple interface where you can:
+- Have conversations with the AI
+- The AI will automatically record important memories from your conversations
+- Retrieve memories when relevant to the conversation
+- View your memory timeline
+
+## Project Structure
+
+```
+hf-memory-chat/
+├── app.py              # Main application
+├── memory_manager.py   # Memory storage and retrieval
+├── chat_interface.py   # Conversational interface
+├── config.py          # Configuration settings
+├── requirements.txt   # Python dependencies
+└── memories/          # Memory storage directory
+    ├── memories.json  # Memory database
+    └── timeline.md    # Human-readable memory timeline
+```
+
+## License
+
+MIT License

README_SPACES.md

@@ -0,0 +1,226 @@
+# 🤖 Memory Chat - Hugging Face Spaces
+
+A conversational AI application built with Hugging Face models that records and remembers user memories. Deployed on Hugging Face Spaces with persistent storage.
+
+## 🚀 Features
+
+- 🤖 **Hugging Face Integration**: Uses DialoGPT for natural conversations
+- 💾 **Memory System**: Automatically records important information from conversations
+- 📚 **Memory Management**: View, search, and manage your memories
+- 🔍 **Smart Retrieval**: AI recalls relevant memories during conversations
+- ☁️ **Persistent Storage**: Memories persist between sessions on the Space
+
+## 🎯 How It Works
+
+1. **Conversation**: Chat naturally with the AI using Hugging Face models
+2. **Memory Detection**: The system automatically detects important information using keywords and patterns
+3. **Memory Storage**: Important details are stored as vector embeddings with metadata
+4. **Memory Retrieval**: When relevant, the AI recalls past memories to provide context
+5. **Timeline View**: View your memory timeline and statistics
+
+## 💡 Memory Recording Examples
+
+The system automatically remembers:
+- Personal preferences: "I love pizza and hate mushrooms"
+- Important facts: "My birthday is December 15th"
+- Locations: "I live in New York"
+- Work/Study: "I work at Google", "I study computer science"
+- Favorites: "My favorite color is blue"
+
+## 🏗️ Architecture
+
+```
+space_app.py          # Main application (optimized for HF Spaces)
+├── memory_manager.py # Memory storage and retrieval
+├── chat_interface.py # Hugging Face model integration
+├── config.py        # Configuration settings
+└── space_requirements.txt # Dependencies for HF Spaces
+```
+
+## 📦 Dependencies
+
+- **Core**: torch, transformers, gradio
+- **Memory**: faiss-cpu, sentence-transformers
+- **Utilities**: numpy, pandas, python-dotenv, rich
+
+## 🔧 Local Development
+
+### Installation
+
+1. Clone this repository
+2. Install dependencies:
+   ```bash
+   pip install -r space_requirements.txt
+   ```
+3. Run the application:
+   ```bash
+   python space_app.py
+   ```
+
+### Testing
+
+Run the test script to verify everything works:
+```bash
+python test_app.py
+```
+
+## ☁️ Deploying to Hugging Face Spaces
+
+### Option 1: Direct Upload (Recommended)
+
+1. **Go to [Hugging Face Spaces](https://huggingface.co/spaces)**
+2. **Click "Create new Space"**
+3. **Choose a name** for your Space
+4. **Select "Gradio"** as the Space type
+5. **Choose "Public"** visibility
+6. **Upload the files**:
+   - `space_app.py` → Rename to `app.py`
+   - `memory_manager.py`
+   - `chat_interface.py`
+   - `config.py`
+   - `space_requirements.txt` → Rename to `requirements.txt`
+   - `README_SPACES.md` → Rename to `README.md`
+
+7. **Commit and push** to create your Space!
+
+### Option 2: Git Clone
+
+1. **Create a new Space** on Hugging Face
+2. **Clone your Space locally**:
+   ```bash
+   git clone https://huggingface.co/spaces/your-username/your-space-name
+   cd your-space-name
+   ```
+
+3. **Copy the files**:
+   ```bash
+   cp /path/to/your/hf-memory-chat/space_app.py app.py
+   cp /path/to/your/hf-memory-chat/memory_manager.py .
+   cp /path/to/your/hf-memory-chat/chat_interface.py .
+   cp /path/to/your/hf-memory-chat/config.py .
+   cp /path/to/your/hf-memory-chat/space_requirements.txt requirements.txt
+   cp /path/to/your/hf-memory-chat/README_SPACES.md README.md
+   ```
+
+4. **Push to HF**:
+   ```bash
+   git add .
+   git commit -m "Initial commit: Memory Chat application"
+   git push origin main
+   ```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+HF Spaces automatically sets up the environment, but you can customize:
+
+- `PORT`: The port to run on (automatically set by Spaces)
+- `SPACE_ID`: Space identifier (automatically set)
+
+### Model Configuration
+
+The application uses `microsoft/DialoGPT-small` by default, which is optimized for:
+- Fast loading times
+- Good conversational quality
+- Lower resource usage
+
+## 🧠 Memory System Details
+
+### Storage
+- **Location**: `/tmp/memories` on HF Spaces (persistent)
+- **Format**: JSON for memories, Markdown for timeline
+- **Indexing**: FAISS for fast similarity search
+
+### Memory Types
+- **General**: General information and facts
+- **Conversation**: Important details from chats
+- **Preferences**: Likes, dislikes, favorites
+- **Important**: Critical information marked as important
+
+### Automatic Recording
+Memories are automatically recorded when:
+- User explicitly requests memory recording
+- Important keywords are detected
+- Personal information patterns are found
+- High importance score is calculated
+
+## 🎨 UI Features
+
+### Chat Interface
+- Clean, responsive design
+- Send messages with Enter key
+- Clear conversation history
+- Automatic memory recording indicators
+
+### Memory Management
+- View memory statistics
+- See recent memories
+- Clear all memories
+- Refresh memory display
+
+### About Section
+- Detailed documentation
+- Usage instructions
+- Feature explanations
+
+## 🚀 Performance Optimizations
+
+### For HF Spaces
+- **Model Selection**: Uses DialoGPT-small for faster loading
+- **Memory Storage**: Optimized for persistent storage
+- **Error Handling**: Graceful fallbacks for model loading
+- **Resource Management**: Efficient memory usage
+
+### Local Development
+- **GPU Support**: Automatic GPU detection if available
+- **Caching**: Model loading optimization
+- **Error Recovery**: Fallback to simple text generation
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **Model Loading Errors**
+   - Usually temporary network issues
+   - Application falls back to simple text generation
+   - Try refreshing the page
+
+2. **Memory Not Persisting**
+   - Ensure you're using the correct app.py file
+   - Check that `/tmp/memories` directory is writable
+   - Verify Space has sufficient storage
+
+3. **Slow Responses**
+   - First-time model loading can be slow
+   - Subsequent requests are cached
+   - Consider using smaller models for faster responses
+
+### Getting Help
+
+- **Hugging Face Community**: [HF Forums](https://discuss.huggingface.co/)
+- **GitHub Issues**: Report bugs and feature requests
+- **Documentation**: Check the About section in the app
+
+## 📄 License
+
+MIT License - see LICENSE file for details
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests for your changes
+5. Submit a pull request
+
+## 🙏 Acknowledgments
+
+- **Hugging Face**: For providing the amazing ecosystem and Spaces platform
+- **Microsoft**: For the DialoGPT models
+- **FAISS Team**: For efficient similarity search
+- **Gradio Team**: For the excellent UI framework
+
+---
+
+**Built with ❤️ using Hugging Face, Gradio, and the power of AI memories**

app.py

@@ -0,0 +1,294 @@
+import os
+from typing import List, Dict, Optional
+import gradio as gr
+from memory_manager import MemoryManager
+from chat_interface import HuggingFaceChat
+from rich.console import Console
+
+console = Console()
+
+class MemoryChatApp:
+    """Main application that combines memory management with Hugging Face chat."""
+
+    def __init__(self):
+        """Initialize the application."""
+        self.memory_manager = MemoryManager()
+        self.chat_interface = HuggingFaceChat()
+
+        # Conversation history
+        self.conversation_history = []
+
+        # Load existing memories
+        summary = self.memory_manager.get_summary()
+        console.print(f"[blue]Loaded {summary['total_memories']} memories[/blue]")
+
+    def should_record_memory(self, user_input: str, ai_response: str) -> bool:
+        """
+        Determine if the conversation should be recorded as a memory.
+
+        Args:
+            user_input: The user's input
+            ai_response: The AI's response
+
+        Returns:
+            True if this should be recorded as a memory
+        """
+        # Keywords that indicate important information
+        important_keywords = [
+            "remember", "important", "note", "fact", "detail", "information",
+            "love", "hate", "like", "dislike", "favorite", "never", "always",
+            "birthday", "anniversary", "special", "urgent", "must", "should"
+        ]
+
+        # Combine user input and AI response for analysis
+        combined_text = f"{user_input} {ai_response}".lower()
+
+        # Check for important keywords
+        for keyword in important_keywords:
+            if keyword in combined_text:
+                return True
+
+        # Check for personal information patterns
+        personal_patterns = [
+            "my name is", "i live in", "i work at", "i study", "my birthday",
+            "my favorite", "i love", "i hate", "i like", "i dislike"
+        ]
+
+        for pattern in personal_patterns:
+            if pattern in combined_text:
+                return True
+
+        return False
+
+    def extract_memory_content(self, user_input: str, ai_response: str) -> str:
+        """
+        Extract the most important information to store as a memory.
+
+        Args:
+            user_input: The user's input
+            ai_response: The AI's response
+
+        Returns:
+            The content to store as a memory
+        """
+        # If user explicitly wants to record something
+        if any(word in user_input.lower() for word in ["remember", "note", "save"]):
+            return user_input
+
+        # Extract personal information
+        personal_info = []
+        if "my name is" in user_input.lower():
+            personal_info.append("User shared their name")
+        if "i live in" in user_input.lower():
+            personal_info.append("User shared their location")
+        if "i work at" in user_input.lower():
+            personal_info.append("User shared their workplace")
+        if "i study" in user_input.lower():
+            personal_info.append("User shared their studies")
+        if "my birthday" in user_input.lower():
+            personal_info.append("User shared their birthday")
+        if "my favorite" in user_input.lower():
+            personal_info.append("User shared a favorite thing")
+
+        if personal_info:
+            return f"User mentioned: {', '.join(personal_info)}. Details: {user_input}"
+
+        # Default to user input if no specific patterns found
+        return user_input
+
+    def chat_with_memory(self, user_input: str) -> str:
+        """
+        Chat with the AI while managing memories.
+
+        Args:
+            user_input: The user's input
+
+        Returns:
+            The AI's response
+        """
+        # Check if model is available
+        if not self.chat_interface.check_model_availability():
+            return "I'm sorry, but I couldn't load the AI model. Please check your internet connection."
+
+        # Add user input to conversation history
+        self.conversation_history.append({"role": "user", "content": user_input})
+
+        # Retrieve relevant memories to provide context
+        relevant_memories = self.memory_manager.retrieve_memories(user_input, k=3)
+
+        # Build context from memories
+        context = ""
+        if relevant_memories:
+            context = "Relevant memories:\n"
+            for memory in relevant_memories[:2]:  # Limit to 2 most relevant
+                context += f"- {memory['content']}\n"
+            context += "\n"
+
+        # Build the prompt with context and conversation history
+        prompt = self.build_prompt(user_input, context)
+
+        # Generate AI response
+        ai_response = self.chat_interface.generate_response(prompt)
+
+        # Add AI response to conversation history
+        self.conversation_history.append({"role": "assistant", "content": ai_response})
+
+        # Check if we should record a memory
+        if self.should_record_memory(user_input, ai_response):
+            memory_content = self.extract_memory_content(user_input, ai_response)
+            context_info = f"During conversation at {self.get_current_time()}"
+
+            self.memory_manager.add_memory(
+                content=memory_content,
+                context=context_info,
+                memory_type="conversation"
+            )
+
+        return ai_response
+
+    def build_prompt(self, user_input: str, context: str) -> str:
+        """
+        Build the prompt for the AI model.
+
+        Args:
+            user_input: The user's input
+            context: Context from relevant memories
+
+        Returns:
+            The prompt to send to the AI model
+        """
+        prompt = f"{context}Human: {user_input}\nAI: "
+        return prompt
+
+    def get_current_time(self) -> str:
+        """Get current time in a readable format."""
+        import datetime
+        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def get_memories_summary(self) -> str:
+        """Get a summary of stored memories."""
+        summary = self.memory_manager.get_summary()
+        memory_types = summary['memory_types']
+
+        summary_text = f"""
+## Memory Summary
+
+**Total Memories:** {summary['total_memories']}
+
+**Memory Types:**
+"""
+        for memory_type, count in memory_types.items():
+            summary_text += f"- {memory_type}: {count}\n"
+
+        return summary_text
+
+    def get_recent_memories(self) -> str:
+        """Get the most recent memories."""
+        recent_memories = self.memory_manager.get_recent_memories()
+        if not recent_memories:
+            return "No memories stored yet."
+
+        memory_text = "## Recent Memories\n\n"
+        for memory in recent_memories:
+            memory_text += f"**{memory['type'].title()}** ({memory['timestamp'][:19]}):\n"
+            memory_text += f"{memory['content']}\n\n"
+
+        return memory_text
+
+    def clear_all_memories(self) -> str:
+        """Clear all memories."""
+        self.memory_manager.clear_memories()
+        return "All memories have been cleared."
+
+    def get_model_info(self) -> str:
+        """Get information about the AI model."""
+        info = self.chat_interface.get_model_info()
+        return f"""
+## Model Information
+
+**Model:** {info['model_name']}
+**Device:** {info['device']}
+**Available:** {'Yes' if info['available'] else 'No'}
+"""
+
+    def run_gradio_interface(self):
+        """Run the Gradio interface."""
+        with gr.Blocks(title="Memory Chat") as demo:
+            gr.Markdown("# 🤖 Memory Chat with Hugging Face")
+
+            with gr.Tab("Chat"):
+                chatbot = gr.Chatbot()
+                msg = gr.Textbox(label="Message", placeholder="Type your message here...")
+                clear = gr.Button("Clear Conversation")
+
+                def user(user_message, history):
+                    # Get AI response
+                    ai_response = self.chat_with_memory(user_message)
+
+                    # Update conversation history
+                    if history is None:
+                        history = []
+                    history.append({"role": "user", "content": user_message})
+                    history.append({"role": "assistant", "content": ai_response})
+                    return "", history
+
+                def clear_history():
+                    self.conversation_history = []
+                    return None
+
+                msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False)
+                clear.click(clear_history, None, chatbot, queue=False)
+
+            with gr.Tab("Memories"):
+                memories_summary = gr.Markdown(value=self.get_memories_summary())
+                recent_memories = gr.Markdown(value=self.get_recent_memories())
+                clear_memories_btn = gr.Button("Clear All Memories")
+                model_info = gr.Markdown(value=self.get_model_info())
+
+                def refresh_memories():
+                    return self.get_memories_summary(), self.get_recent_memories()
+
+                refresh_btn = gr.Button("Refresh Memories")
+                refresh_btn.click(refresh_memories, outputs=[memories_summary, recent_memories])
+                clear_memories_btn.click(self.clear_all_memories, outputs=[])
+
+            with gr.Tab("About"):
+                gr.Markdown("""
+                ## About This Application
+
+                This application combines Hugging Face AI models with a memory system that records important information from your conversations.
+
+                ### Features:
+                - 🤖 Chat with Hugging Face models
+                - 💾 Automatic memory recording
+                - 📚 View and manage your memories
+                - 🔍 Search through your memories
+
+                ### How it works:
+                1. Have a conversation with the AI
+                2. The system automatically detects important information
+                3. Important memories are stored and can be recalled in future conversations
+                4. View your memory timeline and statistics
+
+                ### Memory Types:
+                - **General**: General information and facts
+                - **Conversation**: Important details from chats
+                - **Preferences**: Likes, dislikes, favorites
+                - **Important**: Critical information marked as important
+                """)
+
+        return demo
+
+def main():
+    """Main entry point."""
+    console.print("[green]🚀 Starting Memory Chat Application...[/green]")
+
+    # Create and run the application
+    app = MemoryChatApp()
+
+    # Run Gradio interface
+    demo = app.run_gradio_interface()
+    demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+
+if __name__ == "__main__":
+    main()

chat_interface.py

@@ -0,0 +1,103 @@
+import os
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
+from typing import List, Dict, Optional
+from rich.console import Console
+
+console = Console()
+
+class HuggingFaceChat:
+    """Interface for chatting with Hugging Face models."""
+
+    def __init__(self, model_name: str = "microsoft/DialoGPT-small"):
+        """
+        Initialize the chat interface.
+
+        Args:
+            model_name: The Hugging Face model to use
+        """
+        self.model_name = model_name
+        self.device = 0 if torch.cuda.is_available() else -1  # Use GPU if available
+
+        # Try loading the model with safetensors first
+        try:
+            console.print(f"[blue]Loading model: {model_name}[/blue]")
+            # Try to load with safetensors format first
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name, use_safetensors=True)
+            self.model = AutoModelForCausalLM.from_pretrained(model_name, use_safetensors=True)
+            self.chatbot = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=self.device
+            )
+            console.print("[green]✓ Model loaded successfully[/green]")
+        except Exception as e:
+            console.print(f"[red]Error loading model with safetensors: {e}[/red]")
+            try:
+                # Fallback to regular loading
+                console.print("[yellow]Trying regular loading...[/yellow]")
+                self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+                self.model = AutoModelForCausalLM.from_pretrained(model_name)
+                self.chatbot = pipeline(
+                    "text-generation",
+                    model=self.model,
+                    tokenizer=self.tokenizer,
+                    device=self.device
+                )
+                console.print("[green]✓ Model loaded successfully[/green]")
+            except Exception as e2:
+                console.print(f"[red]Error loading model: {e2}[/red]")
+                console.print("[yellow]Falling back to simple text generation...[/yellow]")
+                self.chatbot = None
+
+    def generate_response(self, prompt: str, max_length: int = 1000) -> str:
+        """
+        Generate a response to a prompt.
+
+        Args:
+            prompt: The input prompt
+            max_length: Maximum length of the generated response
+
+        Returns:
+            The generated response
+        """
+        if not self.chatbot:
+            return "I'm sorry, but I couldn't load the model. Please check your internet connection and model availability."
+
+        try:
+            # Generate response
+            response = self.chatbot(
+                prompt,
+                max_length=max_length,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.9,
+                repetition_penalty=1.2,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+
+            # Extract the generated text
+            generated_text = response[0]['generated_text']
+
+            # Remove the prompt from the response if it's included
+            if generated_text.startswith(prompt):
+                generated_text = generated_text[len(prompt):].strip()
+
+            return generated_text
+
+        except Exception as e:
+            console.print(f"[red]Error generating response: {e}[/red]")
+            return "I'm sorry, but I encountered an error while generating a response."
+
+    def check_model_availability(self) -> bool:
+        """Check if the model is available."""
+        return self.chatbot is not None
+
+    def get_model_info(self) -> Dict:
+        """Get information about the loaded model."""
+        return {
+            "model_name": self.model_name,
+            "device": "GPU" if self.device == 0 else "CPU",
+            "available": self.chatbot is not None
+        }

config.py

@@ -0,0 +1,44 @@
+"""
+Configuration settings for the Memory Chat application.
+"""
+
+# Model configuration
+DEFAULT_MODEL = "microsoft/DialoGPT-medium"
+ALTERNATIVE_MODELS = [
+    "microsoft/DialoGPT-small",
+    "microsoft/DialoGPT-large",
+    "facebook/blenderbot-400M-distill",
+]
+
+# Memory configuration
+MEMORY_DIR = "memories"
+EMBEDDING_MODEL = "all-MiniLM-L6-v2"
+MAX_RETRIEVED_MEMORIES = 5
+MEMORY_IMPORTANCE_THRESHOLD = 0.7
+
+# Chat configuration
+MAX_RESPONSE_LENGTH = 1000
+TEMPERATURE = 0.7
+TOP_P = 0.9
+REPETITION_PENALTY = 1.2
+
+# UI configuration
+GRADIO_TITLE = "Memory Chat with Hugging Face"
+GRADIO_THEME = "soft"
+
+# Keywords that trigger memory recording
+MEMORY_TRIGGER_KEYWORDS = [
+    "remember", "note", "save", "important", "fact", "detail",
+    "my name is", "i live in", "i work at", "i study",
+    "my birthday", "my favorite", "i love", "i hate", "i like",
+    "never", "always", "often", "every", "daily", "weekly"
+]
+
+# Memory types
+MEMORY_TYPES = {
+    "general": "General information and facts",
+    "conversation": "Important details from chats",
+    "preference": "Likes, dislikes, favorites",
+    "important": "Critical information marked as important",
+    "personal": "Personal information and details"
+}

deploy_to_spaces.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""
+Direct upload script to Hugging Face Spaces.
+This script will guide you through creating and uploading your Memory Chat application.
+"""
+
+import os
+import sys
+import subprocess
+import webbrowser
+from pathlib import Path
+
+def check_prerequisites():
+    """Check if prerequisites are installed."""
+    print("🔍 Checking prerequisites...")
+
+    # Check if git is installed
+    try:
+        result = subprocess.run(['git', '--version'], capture_output=True, text=True)
+        if result.returncode == 0:
+            print("✅ Git is installed")
+        else:
+            print("❌ Git is not installed. Please install Git first.")
+            return False
+    except FileNotFoundError:
+        print("❌ Git is not installed. Please install Git first.")
+        return False
+
+    # Check if files exist
+    required_files = [
+        'app.py',
+        'memory_manager.py',
+        'chat_interface.py',
+        'config.py',
+        'requirements.txt',
+        'README.md'
+    ]
+
+    missing_files = []
+    for file in required_files:
+        if not os.path.exists(file):
+            missing_files.append(file)
+
+    if missing_files:
+        print(f"❌ Missing files: {', '.join(missing_files)}")
+        print("Please ensure all required files are in the current directory.")
+        return False
+    else:
+        print("✅ All required files found")
+
+    return True
+
+def create_space():
+    """Guide user through creating a Space on Hugging Face."""
+    print("\n🌐 Creating Hugging Face Space...")
+
+    print("1. Open your web browser and go to: https://huggingface.co/spaces")
+    print("2. Sign in to your Hugging Face account")
+    print("3. Click 'Create new Space' (top right)")
+    print("4. Choose a Space name (e.g., 'your-username/memory-chat')")
+    print("5. Select 'Gradio' as the Space type")
+    print("6. Choose 'Public' visibility")
+    print("7. Click 'Create Space'")
+
+    input("\nPress Enter after you've created your Space...")
+
+def get_space_url():
+    """Get the Space URL from user."""
+    print("\n📍 Please enter your Space URL:")
+    print("It should look like: https://huggingface.co/spaces/your-username/your-space-name")
+    space_url = input("Space URL: ").strip()
+
+    if not space_url.startswith("https://huggingface.co/spaces/"):
+        print("❌ Invalid URL format. Please enter a valid Hugging Face Space URL.")
+        return get_space_url()
+
+    return space_url
+
+def clone_space_repo(space_url):
+    """Clone the Space repository."""
+    print(f"\n📥 Cloning Space repository: {space_url}")
+
+    # Extract the repo name from URL
+    repo_name = space_url.split('/')[-1]
+    username = space_url.split('/')[-2]
+
+    clone_url = f"https://huggingface.co/spaces/{username}/{repo_name}"
+
+    try:
+        subprocess.run(['git', 'clone', clone_url], check=True)
+        return repo_name
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to clone repository: {e}")
+        return None
+
+def copy_files_to_repo(repo_name):
+    """Copy files to the cloned repository."""
+    print(f"\n📁 Copying files to {repo_name}...")
+
+    files_to_copy = [
+        ('app.py', 'app.py'),
+        ('memory_manager.py', 'memory_manager.py'),
+        ('chat_interface.py', 'chat_interface.py'),
+        ('config.py', 'config.py'),
+        ('requirements.txt', 'requirements.txt'),
+        ('README.md', 'README.md')
+    ]
+
+    for src, dst in files_to_copy:
+        try:
+            subprocess.run(['cp', src, f"{repo_name}/{dst}"], check=True)
+            print(f"✅ Copied {src} -> {repo_name}/{dst}")
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to copy {src}: {e}")
+            return False
+
+    return True
+
+def commit_and_push(repo_name, username):
+    """Commit and push changes to the Space."""
+    print(f"\n🚀 Committing and pushing changes...")
+
+    try:
+        # Change to repo directory
+        os.chdir(repo_name)
+
+        # Add files
+        subprocess.run(['git', 'add', '.'], check=True)
+
+        # Commit
+        subprocess.run(['git', 'commit', '-m', 'Initial commit: Memory Chat application'], check=True)
+
+        # Push
+        subprocess.run(['git', 'push', 'origin', 'main'], check=True)
+
+        print("✅ Successfully pushed to Hugging Face Spaces!")
+        print(f"🌐 Your Space will be available at: https://huggingface.co/spaces/{username}/{repo_name}")
+
+        return True
+
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to commit/push: {e}")
+        return False
+
+def main():
+    """Main deployment function."""
+    print("🚀 Memory Chat - Hugging Face Spaces Deployment")
+    print("=" * 50)
+
+    # Check prerequisites
+    if not check_prerequisites():
+        sys.exit(1)
+
+    # Create Space on Hugging Face
+    create_space()
+
+    # Get Space URL
+    space_url = get_space_url()
+    username = space_url.split('/')[-2]
+
+    # Clone the Space repository
+    repo_name = clone_space_repo(space_url)
+    if not repo_name:
+        sys.exit(1)
+
+    # Copy files
+    if not copy_files_to_repo(repo_name):
+        sys.exit(1)
+
+    # Commit and push
+    if commit_and_push(repo_name, username):
+        print("\n🎉 Deployment successful!")
+        print("Your Space will build automatically and be available shortly.")
+        print("Check the 'Logs' tab in your Space for build status.")
+    else:
+        print("\n❌ Deployment failed. Please check the error messages above.")
+
+if __name__ == "__main__":
+    main()

git_deploy.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Git-based deployment to Hugging Face Spaces.
+This script will guide you through creating and deploying via Git.
+"""
+
+import os
+import sys
+import subprocess
+import getpass
+import webbrowser
+from pathlib import Path
+
+def run_command(command, description=""):
+    """Run a shell command and return success status."""
+    print(f"🔄 {description}")
+    try:
+        result = subprocess.run(command, shell=True, check=True, text=True, capture_output=True)
+        if result.stdout:
+            print(f"✅ {result.stdout.strip()}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error: {e}")
+        if e.stderr:
+            print(f"Error details: {e.stderr.strip()}")
+        return False
+
+def check_git():
+    """Check if git is installed and configured."""
+    print("🔍 Checking Git...")
+    if not run_command("git --version", "Checking Git installation"):
+        print("❌ Git is not installed. Please install Git first.")
+        return False
+
+    # Check if user is configured
+    name_result = subprocess.run("git config user.name", shell=True, capture_output=True, text=True)
+    email_result = subprocess.run("git config user.email", shell=True, capture_output=True, text=True)
+
+    if not name_result.stdout.strip():
+        print("⚠️  Git user name not configured")
+        name = input("Enter your Git user name: ")
+        run_command(f'git config --global user.name "{name}"', "Setting Git user name")
+
+    if not email_result.stdout.strip():
+        print("⚠️  Git user email not configured")
+        email = input("Enter your Git user email: ")
+        run_command(f'git config --global user.email "{email}"', "Setting Git user email")
+
+    return True
+
+def get_hf_token():
+    """Get Hugging Face API token."""
+    print("\n🔐 Getting Hugging Face credentials...")
+
+    # Check if token is set as environment variable
+    hf_token = os.getenv('HF_TOKEN')
+    if hf_token:
+        print("✅ Found HF_TOKEN environment variable")
+        return hf_token
+
+    print("Please get your Hugging Face API token:")
+    print("1. Go to: https://huggingface.co/settings/tokens")
+    print("2. Click 'New token'")
+    print("3. Set name: 'spaces-deploy'")
+    print("4. Set role: 'write'")
+    print("5. Copy the token")
+
+    webbrowser.open("https://huggingface.co/settings/tokens")
+
+    hf_token = getpass.getpass("Enter your Hugging Face API token: ")
+    return hf_token
+
+def create_space():
+    """Create a new Space on Hugging Face."""
+    print("\n🌐 Creating Hugging Face Space...")
+
+    username = input("Enter your Hugging Face username: ")
+    space_name = input("Enter your Space name (e.g., 'memory-chat'): ")
+
+    # Create Space via API
+    hf_token = get_hf_token()
+
+    api_url = f"https://huggingface.co/api/spaces/{username}/{space_name}"
+    create_cmd = f'curl -X POST {api_url} -H "Authorization: Bearer {hf_token}" -H "Content-Type: application/json" -d \'{{"private": false, "sdk": "gradio"}}\''
+
+    print("Creating Space...")
+    if run_command(create_cmd, "Creating Space on Hugging Face"):
+        print(f"✅ Space created: https://huggingface.co/spaces/{username}/{space_name}")
+        return username, space_name
+    else:
+        print("❌ Failed to create Space. Please check your credentials and try again.")
+        return None, None
+
+def setup_git_remote(username, space_name, hf_token):
+    """Setup Git remote for the Space."""
+    print(f"\n🔗 Setting up Git remote for {username}/{space_name}...")
+
+    remote_url = f"https://USER:TOKEN@huggingface.co/spaces/{username}/{space_name}"
+    remote_url = remote_url.replace("USER", username).replace("TOKEN", hf_token)
+
+    if run_command(f"git remote add origin {remote_url}", "Adding Git remote"):
+        return True
+    else:
+        # Try removing and re-adding
+        run_command("git remote remove origin", "Removing existing remote")
+        return run_command(f"git remote add origin {remote_url}", "Adding Git remote")
+
+def deploy_to_spaces():
+    """Main deployment function."""
+    print("🚀 Memory Chat - Git Deployment to Hugging Face Spaces")
+    print("=" * 60)
+
+    # Check prerequisites
+    if not check_git():
+        sys.exit(1)
+
+    # Check if we're in a git repo
+    if not os.path.exists(".git"):
+        print("🔄 Initializing Git repository...")
+        if not run_command("git init", "Initializing Git repository"):
+            sys.exit(1)
+
+    # Check if files exist
+    required_files = ['app.py', 'memory_manager.py', 'chat_interface.py', 'config.py', 'requirements.txt', 'README.md']
+    missing_files = [f for f in required_files if not os.path.exists(f)]
+
+    if missing_files:
+        print(f"❌ Missing files: {', '.join(missing_files)}")
+        print("Please ensure all required files are in the current directory.")
+        sys.exit(1)
+
+    # Create Space or get existing Space details
+    choice = input("\nDo you want to create a new Space? (y/n): ").lower().strip()
+    if choice == 'y':
+        username, space_name = create_space()
+        if not username:
+            sys.exit(1)
+    else:
+        username = input("Enter your Hugging Face username: ")
+        space_name = input("Enter your existing Space name: ")
+
+    # Setup Git remote
+    hf_token = get_hf_token()
+    if not setup_git_remote(username, space_name, hf_token):
+        print("❌ Failed to setup Git remote")
+        sys.exit(1)
+
+    # Add files and commit
+    print("\n📁 Adding files to Git...")
+    if not run_command("git add .", "Adding all files"):
+        sys.exit(1)
+
+    if not run_command('git commit -m "Initial commit: Memory Chat application"', "Creating commit"):
+        sys.exit(1)
+
+    # Push to Hugging Face
+    print("\n🚀 Pushing to Hugging Face Spaces...")
+    if not run_command("git push -u origin main", "Pushing to remote"):
+        print("❌ Failed to push to remote. Trying with force...")
+        if not run_command("git push -u origin main --force", "Force pushing to remote"):
+            sys.exit(1)
+
+    print(f"\n🎉 Successfully deployed to: https://huggingface.co/spaces/{username}/{space_name}")
+    print("🌐 Your Space will build automatically. Check the 'Logs' tab for progress.")
+
+    return username, space_name
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) > 1 and sys.argv[1] == "--help":
+        print(__doc__)
+        sys.exit(0)
+
+    try:
+        deploy_to_spaces()
+    except KeyboardInterrupt:
+        print("\n❌ Deployment cancelled by user")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n❌ Deployment failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

memories/memories.json

@@ -0,0 +1,791 @@
+[
+  {
+    "id": 1,
+    "content": "User mentioned: User shared their name. Details: hello my name is edwin mauricio",
+    "context": "During conversation at 2026-01-09 22:25:16",
+    "type": "conversation",
+    "timestamp": "2026-01-09T22:25:17.112604",
+    "embedding": [
+      -0.057125337421894073,
+      -0.008446086198091507,
+      -0.07326115667819977,
+      -0.0026685793418437243,
+      -0.05792270228266716,
+      -0.015340020880103111,
+      0.0979149118065834,
+      -0.0033453742507845163,
+      -0.0009754750062711537,
+      -0.04974544048309326,
+      0.009946444071829319,
+      -0.021322263404726982,
+      0.02255190908908844,
+      0.011175232008099556,
+      -0.0348091684281826,
+      0.03492099419236183,
+      -0.006262023933231831,
+      0.002294063102453947,
+      -0.03296710178256035,
+      -0.06508582830429077,
+      -0.05960575118660927,
+      0.00016545435937587172,
+      -0.05329013243317604,
+      0.010785967111587524,
+      0.07438857853412628,
+      -0.007583011873066425,
+      -0.002487051533535123,
+      0.09221069514751434,
+      -0.03870362043380737,
+      0.01354052685201168,
+      0.020654771476984024,
+      -0.027539966627955437,
+      0.09750374406576157,
+      0.0656624585390091,
+      -0.042317237704992294,
+      -0.02733740396797657,
+      -0.08252953737974167,
+      -0.005312549881637096,
+      -0.010010665282607079,
+      -0.08037310838699341,
+      -0.006242047529667616,
+      -0.03140488639473915,
+      -0.006270831450819969,
+      0.06866245716810226,
+      -0.07823919504880905,
+      0.08782817423343658,
+      0.021853437647223473,
+      0.04021047428250313,
+      0.02399042434990406,
+      0.09958421438932419,
+      -0.08803551644086838,
+      -0.026885293424129486,
+      0.028302989900112152,
+      -0.006180956494063139,
+      0.015449032187461853,
+      -0.023429473862051964,
+      -2.770853097899817e-05,
+      0.06675168126821518,
+      -0.01881526969373226,
+      -0.03623613715171814,
+      -0.0446024015545845,
+      -0.0018725040135905147,
+      -0.03358656167984009,
+      0.0025525959208607674,
+      0.006960983853787184,
+      -0.04203746095299721,
+      -0.07680106908082962,
+      -0.025578830391168594,
+      0.05235536769032478,
+      -0.06356118619441986,
+      0.010259767062962055,
+      0.0643501728773117,
+      -0.007683092728257179,
+      -0.01564478687942028,
+      0.010853197425603867,
+      0.043562620878219604,
+      -0.006737628020346165,
+      -0.0021607333328574896,
+      -0.037271786481142044,
+      0.0022986254189163446,
+      -0.03336505964398384,
+      0.01152387447655201,
+      -0.08332626521587372,
+      -0.08827913552522659,
+      -0.01808939315378666,
+      0.06315665692090988,
+      -0.027659477666020393,
+      -0.05011877790093422,
+      -0.012806248851120472,
+      -0.037625402212142944,
+      0.0910073071718216,
+      0.10150371491909027,
+      0.06187543645501137,
+      -0.04064022749662399,
+      -0.04699157550930977,
+      -0.018568649888038635,
+      0.009093087166547775,
+      0.08078845590353012,
+      -0.16335779428482056,
+      0.09966878592967987,
+      -0.047211308032274246,
+      0.06600812822580338,
+      0.016125407069921494,
+      0.012649456970393658,
+      0.04208759218454361,
+      0.06756006181240082,
+      -0.008905795402824879,
+      0.008182586170732975,
+      -0.022753743454813957,
+      -0.013720559887588024,
+      -0.005981684196740389,
+      -0.02735157683491707,
+      -0.09707805514335632,
+      -0.01930655911564827,
+      0.07630596309900284,
+      -0.0021960127633064985,
+      -0.023808499798178673,
+      0.036347340792417526,
+      0.03259022533893585,
+      -0.016531927511096,
+      -0.029386838898062706,
+      0.0006996437441557646,
+      -0.043099209666252136,
+      0.013572637923061848,
+      -0.04598405584692955,
+      0.02197236940264702,
+      0.018159834668040276,
+      -3.8097806348461397e-34,
+      0.019611947238445282,
+      0.052307698875665665,
+      0.04324403405189514,
+      0.08529195189476013,
+      -0.044940344989299774,
+      -0.0027374771889299154,
+      -0.10778433829545975,
+      0.00043052202090620995,
+      -0.06361633539199829,
+      -0.11566772311925888,
+      0.0866595134139061,
+      0.07818538695573807,
+      0.04759884625673294,
+      -0.03842480108141899,
+      -0.027971411123871803,
+      -0.002866580383852124,
+      0.029747571796178818,
+      -0.008215673267841339,
+      0.03134743124246597,
+      0.12150918692350388,
+      0.011035402305424213,
+      -0.05886666476726532,
+      0.030577510595321655,
+      0.0692368820309639,
+      -0.014443919993937016,
+      -0.024542514234781265,
+      0.02816048637032509,
+      -0.09045267850160599,
+      0.15432702004909515,
+      0.038488246500492096,
+      -0.023578844964504242,
+      0.05558973178267479,
+      -0.03265468031167984,
+      -0.01619907096028328,
+      -0.0043658665381371975,
+      0.050767477601766586,
+      0.04110734164714813,
+      -0.05129428207874298,
+      -0.10075933486223221,
+      0.051519718021154404,
+      0.024081239476799965,
+      0.017909986898303032,
+      -0.03146861866116524,
+      -0.04663139581680298,
+      -0.1365085244178772,
+      -0.034571852535009384,
+      -0.015411549247801304,
+      0.11987785249948502,
+      0.016943957656621933,
+      -0.0049460092559456825,
+      -0.07557415962219238,
+      0.004541031084954739,
+      -0.10237791389226913,
+      0.023688582703471184,
+      0.007004923187196255,
+      -0.04844467341899872,
+      -0.028594058007001877,
+      0.026007648557424545,
+      -0.039679963141679764,
+      -0.03582621365785599,
+      0.027910927310585976,
+      0.03410184755921364,
+      0.03208622708916664,
+      0.005524757318198681,
+      -0.06722851097583771,
+      -0.09288894385099411,
+      0.007131680846214294,
+      -0.012614968232810497,
+      0.049690842628479004,
+      0.026632025837898254,
+      -0.007178872358053923,
+      -0.007110861595720053,
+      0.03837954252958298,
+      0.01662914827466011,
+      -0.06606756895780563,
+      -0.007788670249283314,
+      -0.042646374553442,
+      0.07128605991601944,
+      -0.006830724887549877,
+      0.027400994673371315,
+      0.01368551142513752,
+      -0.032182540744543076,
+      -0.044077068567276,
+      -0.04613516107201576,
+      -0.09208519756793976,
+      0.11833278089761734,
+      -0.07311288267374039,
+      -0.0008083946304395795,
+      -0.11028492450714111,
+      0.03174746409058571,
+      0.0027827059384435415,
+      0.07041648775339127,
+      0.08908120542764664,
+      0.07946006208658218,
+      -0.05757908523082733,
+      -3.122636458112096e-33,
+      -0.02531912364065647,
+      0.00385535997338593,
+      -0.019620083272457123,
+      -0.0665917620062828,
+      0.04982120916247368,
+      -0.05796438083052635,
+      -0.04772398993372917,
+      0.08149518817663193,
+      -0.08067349344491959,
+      0.031712692230939865,
+      0.03125898540019989,
+      0.0011805040994659066,
+      0.023329248651862144,
+      -0.024804499000310898,
+      -0.008077752776443958,
+      0.015345391817390919,
+      0.08851150423288345,
+      0.04382757842540741,
+      -0.009666668251156807,
+      -0.05505415424704552,
+      -0.05158616974949837,
+      0.06651522219181061,
+      -0.05985570326447487,
+      -0.02294558845460415,
+      0.009721768088638783,
+      -0.0520574152469635,
+      0.06250109523534775,
+      -0.006866733077913523,
+      -0.021205900236964226,
+      -0.05674334615468979,
+      0.013122009113430977,
+      0.07283326238393784,
+      -0.1287110447883606,
+      -0.11028259247541428,
+      -0.06954318284988403,
+      0.030362773686647415,
+      -0.033978335559368134,
+      0.10428588837385178,
+      0.013802451081573963,
+      -0.004419572651386261,
+      0.033986568450927734,
+      0.08443409949541092,
+      0.012827146798372269,
+      -0.00836518406867981,
+      -0.07776367664337158,
+      -0.00741546880453825,
+      -0.02556561306118965,
+      -0.06659505516290665,
+      -0.00032322993502020836,
+      0.07700251042842865,
+      0.017850907519459724,
+      -0.09126944839954376,
+      0.047602418810129166,
+      -0.08610661327838898,
+      -0.011727987788617611,
+      0.001727365073747933,
+      0.0655781552195549,
+      -0.020107639953494072,
+      0.06260063499212265,
+      -0.01636842079460621,
+      -0.07583952695131302,
+      0.005413348320871592,
+      -0.06524797528982162,
+      0.08053403347730637,
+      0.03917818143963814,
+      -0.02600565366446972,
+      -0.010719946585595608,
+      0.03897366672754288,
+      0.012868308462202549,
+      -0.021330857649445534,
+      0.08201935887336731,
+      -0.04026496782898903,
+      0.02742106094956398,
+      0.03216073662042618,
+      -0.010248266160488129,
+      0.025661468505859375,
+      -0.006426472682505846,
+      0.0027222500648349524,
+      0.0059382617473602295,
+      0.06493712216615677,
+      0.018517453223466873,
+      0.0663008987903595,
+      0.009702255018055439,
+      0.03144288435578346,
+      0.010866508819162846,
+      -0.041125524789094925,
+      0.04375699162483215,
+      0.050250548869371414,
+      0.009397868998348713,
+      0.05026782676577568,
+      0.0239596925675869,
+      -0.015477035194635391,
+      -0.03177541121840477,
+      -0.10046987235546112,
+      -0.03420412167906761,
+      -2.448786062814179e-08,
+      0.006381123326718807,
+      -0.022108735516667366,
+      0.036654602736234665,
+      0.09345582127571106,
+      -0.018864160403609276,
+      0.05616375803947449,
+      0.015253727324306965,
+      0.052468426525592804,
+      0.005437702871859074,
+      0.05385417863726616,
+      -0.04094225540757179,
+      0.03294241055846214,
+      -0.005734832491725683,
+      0.014899514615535736,
+      0.09180409461259842,
+      -0.05105292797088623,
+      0.00816957838833332,
+      0.05021567642688751,
+      -0.043644584715366364,
+      -0.061980511993169785,
+      -0.05464288592338562,
+      0.0018051754450425506,
+      -0.010898329317569733,
+      -0.050912417471408844,
+      0.019909996539354324,
+      0.019790442660450935,
+      0.003015709575265646,
+      -0.006313270423561335,
+      -0.08978044241666794,
+      -0.025397317484021187,
+      -0.04049055278301239,
+      0.07724948972463608,
+      0.0444415882229805,
+      -0.031838931143283844,
+      -0.01125660166144371,
+      0.019191239029169083,
+      0.0001980650267796591,
+      -0.029844986274838448,
+      -0.03391929715871811,
+      -0.04952402040362358,
+      -0.06361277401447296,
+      0.0064875963144004345,
+      0.03808775544166565,
+      0.012116416357457638,
+      0.07537489384412766,
+      0.055296678096055984,
+      0.02399350143969059,
+      -0.08425548672676086,
+      -0.03247550129890442,
+      0.0076597644947469234,
+      -0.06612659245729446,
+      0.0009295226191170514,
+      0.10263608396053314,
+      0.07443418353796005,
+      0.01991223357617855,
+      -0.019950730726122856,
+      -0.0030020412523299456,
+      0.09624635428190231,
+      0.06115877628326416,
+      -0.09458866715431213,
+      -0.008059244602918625,
+      0.05025295913219452,
+      -0.10532546043395996,
+      0.06978560239076614
+    ],
+    "importance": 0.5,
+    "relevance_score": 3.4028234663852886e+38
+  },
+  {
+    "id": 2,
+    "content": "User mentioned: User shared their name. Details: my name is edwin",
+    "context": "During conversation at 2026-01-09 22:26:39",
+    "type": "conversation",
+    "timestamp": "2026-01-09T22:26:39.513887",
+    "embedding": [
+      -0.05643876641988754,
+      0.006340052932500839,
+      -0.0825352817773819,
+      -0.007329378742724657,
+      -0.05459514632821083,
+      0.013580982573330402,
+      0.11820705980062485,
+      0.010445385240018368,
+      0.0011700979666784406,
+      -0.060769662261009216,
+      -0.0022343441378325224,
+      -0.01490565575659275,
+      0.048100657761096954,
+      -0.014894277788698673,
+      -0.03501866012811661,
+      0.0377735011279583,
+      0.0013687534956261516,
+      -0.009943850338459015,
+      -0.07332146167755127,
+      -0.08760516345500946,
+      -0.0757228210568428,
+      0.016015511006116867,
+      -0.041063662618398666,
+      -0.01715191639959812,
+      0.09080062061548233,
+      0.029597856104373932,
+      0.008221178315579891,
+      0.08211426436901093,
+      -0.03264711797237396,
+      0.025607872754335403,
+      0.02878875844180584,
+      -0.03647315874695778,
+      0.06389915198087692,
+      0.06119699031114578,
+      -0.06896678358316422,
+      -0.06345822662115097,
+      -0.11721869558095932,
+      -0.008107546716928482,
+      0.030358554795384407,
+      -0.08242306858301163,
+      -0.007212796248495579,
+      -0.03161206841468811,
+      -0.00012109880481148139,
+      0.049195464700460434,
+      -0.08571715652942657,
+      0.11025681346654892,
+      0.004261036869138479,
+      0.03962382674217224,
+      0.024767208844423294,
+      0.09271345287561417,
+      -0.05902561917901039,
+      -0.03769134730100632,
+      0.02065889537334442,
+      0.0032142195850610733,
+      -0.006228269077837467,
+      -0.025914793834090233,
+      0.0007751010707579553,
+      0.04010569304227829,
+      -0.03272290900349617,
+      0.002311297692358494,
+      -0.02982933074235916,
+      0.00692555820569396,
+      -0.015722505748271942,
+      0.02992244064807892,
+      -0.021927468478679657,
+      -0.014504549093544483,
+      -0.038329508155584335,
+      -0.03579073026776314,
+      0.07539373636245728,
+      -0.05879088491201401,
+      0.01757119782269001,
+      0.07439084351062775,
+      -0.021343529224395752,
+      -0.0060766832903027534,
+      0.009848019108176231,
+      0.024815808981657028,
+      -0.014892222359776497,
+      0.025040600448846817,
+      -0.04609399661421776,
+      -0.026013556867837906,
+      -0.0754813700914383,
+      0.06303617358207703,
+      -0.06724913418292999,
+      -0.09214217215776443,
+      -0.043927520513534546,
+      0.08804777264595032,
+      -0.025010058656334877,
+      -0.043386854231357574,
+      -0.023963088169693947,
+      -0.03483190760016441,
+      0.10186033695936203,
+      0.056073036044836044,
+      0.10330173373222351,
+      -0.03682665154337883,
+      -0.05081573873758316,
+      -0.0105367973446846,
+      0.01409026701003313,
+      0.05235733464360237,
+      -0.15517717599868774,
+      0.08759670704603195,
+      -0.06892723590135574,
+      0.07809031754732132,
+      0.002823751186951995,
+      0.0049567739479243755,
+      0.04152959585189819,
+      0.04690350219607353,
+      0.012146921828389168,
+      0.005614860914647579,
+      -0.02754994109272957,
+      -0.011704501695930958,
+      0.02488057315349579,
+      -0.054516419768333435,
+      -0.08275116980075836,
+      -0.015179515816271305,
+      0.06472513824701309,
+      0.0029180096462368965,
+      -0.009562947787344456,
+      0.02914739027619362,
+      0.02885391376912594,
+      0.0018100666347891092,
+      -0.027522297576069832,
+      0.009483659639954567,
+      -0.05186343565583229,
+      0.016881249845027924,
+      -0.054728783667087555,
+      0.0021105981431901455,
+      0.018439166247844696,
+      -3.0879237425903294e-33,
+      -0.012961992993950844,
+      0.0596257783472538,
+      0.0385788232088089,
+      0.08194147050380707,
+      -0.04683526232838631,
+      0.01699860766530037,
+      -0.12882420420646667,
+      0.010512175038456917,
+      -0.06750291585922241,
+      -0.08365614712238312,
+      0.06760998070240021,
+      0.06317827850580215,
+      0.053511008620262146,
+      -0.07711957395076752,
+      -0.02098703756928444,
+      0.02011113241314888,
+      0.03377315029501915,
+      0.019801165908575058,
+      0.028557846322655678,
+      0.11588888615369797,
+      0.03532402217388153,
+      -0.03663478419184685,
+      0.022024964913725853,
+      0.04794193431735039,
+      -0.025263769552111626,
+      -0.038302477449178696,
+      0.05644823983311653,
+      -0.06020880863070488,
+      0.1417873203754425,
+      0.02940896339714527,
+      -0.025076601654291153,
+      0.04585685953497887,
+      -0.022619565948843956,
+      0.01040772907435894,
+      0.016547253355383873,
+      0.05253582447767258,
+      0.06759890168905258,
+      -0.025432979688048363,
+      -0.09293048083782196,
+      0.05766065791249275,
+      0.0553952120244503,
+      0.0060941074043512344,
+      -0.0580531470477581,
+      -0.029363097622990608,
+      -0.12619534134864807,
+      0.0008715441217646003,
+      0.02210158295929432,
+      0.11483465880155563,
+      0.012663383968174458,
+      -0.011448797769844532,
+      -0.06519268453121185,
+      0.003468132112175226,
+      -0.04319766163825989,
+      0.024161361157894135,
+      0.0003276085772085935,
+      -0.05301162600517273,
+      -0.007179405074566603,
+      0.01400463655591011,
+      -0.03051787056028843,
+      -0.0337553508579731,
+      0.027168763801455498,
+      0.03457282483577728,
+      0.008677193894982338,
+      0.012068578042089939,
+      -0.06278853118419647,
+      -0.09913598746061325,
+      -0.003426732961088419,
+      -0.03781317546963692,
+      0.027403216809034348,
+      0.020420311018824577,
+      -0.016337284818291664,
+      0.015417809598147869,
+      0.04849385470151901,
+      0.01005076989531517,
+      -0.03850109502673149,
+      -0.007422123569995165,
+      -0.07312804460525513,
+      0.06765672564506531,
+      -0.019966645166277885,
+      0.04609200358390808,
+      -0.015026352368295193,
+      -0.03275790065526962,
+      -0.04104631394147873,
+      -0.022550813853740692,
+      -0.09472212195396423,
+      0.06362135708332062,
+      -0.09414522349834442,
+      0.015337715856730938,
+      -0.10672953724861145,
+      0.02225402370095253,
+      0.013498932123184204,
+      0.09225743263959885,
+      0.07570606470108032,
+      0.0995408445596695,
+      -0.03965884447097778,
+      -6.573768485981327e-34,
+      -0.07139831781387329,
+      -0.009486247785389423,
+      -0.03551442176103592,
+      -0.05034289509057999,
+      0.08578179031610489,
+      -0.05234121158719063,
+      -0.03845597803592682,
+      0.058435436338186264,
+      -0.05663018673658371,
+      0.024962928146123886,
+      0.035042550414800644,
+      -0.0068955980241298676,
+      0.0008154893876053393,
+      -0.028416849672794342,
+      0.015835579484701157,
+      0.004946228116750717,
+      0.0798116996884346,
+      0.04050973802804947,
+      -0.010325375013053417,
+      -0.043313220143318176,
+      -0.05247000977396965,
+      0.06197315454483032,
+      -0.049068648368120193,
+      -0.03643595427274704,
+      0.010386759415268898,
+      -0.03060474991798401,
+      0.07041051238775253,
+      -0.010620801709592342,
+      -0.0018937480635941029,
+      -0.040896959602832794,
+      0.024643540382385254,
+      0.03827774152159691,
+      -0.12103264033794403,
+      -0.09143630415201187,
+      -0.08608811348676682,
+      0.012372898869216442,
+      -0.01163309346884489,
+      0.08217961341142654,
+      -0.006975108757615089,
+      -0.033556047827005386,
+      0.015503179281949997,
+      0.07439612597227097,
+      0.01514509879052639,
+      0.02855636551976204,
+      -0.05927750840783119,
+      -0.04735465347766876,
+      -0.03468931466341019,
+      -0.07146055996417999,
+      0.02044123411178589,
+      0.0860150158405304,
+      0.009616846218705177,
+      -0.09097566455602646,
+      0.04584784433245659,
+      -0.09588448703289032,
+      -0.012232123874127865,
+      -0.0003395208332221955,
+      0.08498546481132507,
+      -0.011024896055459976,
+      0.09244536608457565,
+      0.00946288462728262,
+      -0.0763309970498085,
+      0.011293893679976463,
+      -0.04752162843942642,
+      0.11801411956548691,
+      0.02423446998000145,
+      -0.031438689678907394,
+      0.004808045923709869,
+      0.05994592234492302,
+      0.020935019478201866,
+      -0.03998388350009918,
+      0.09672801196575165,
+      -0.05240225791931152,
+      0.02402358688414097,
+      0.008902295492589474,
+      0.016130104660987854,
+      0.018190735951066017,
+      0.02256973460316658,
+      -0.004295494873076677,
+      -0.020879359915852547,
+      0.06166696920990944,
+      0.02340847998857498,
+      0.04847263917326927,
+      0.007622626144438982,
+      0.045097313821315765,
+      -0.02581077069044113,
+      -0.06806942820549011,
+      0.04291797801852226,
+      0.05493941903114319,
+      -0.017246540635824203,
+      0.040700968354940414,
+      0.03668623045086861,
+      -0.036395397037267685,
+      -0.039607174694538116,
+      -0.0674767717719078,
+      -0.02262483909726143,
+      -1.983555719675678e-08,
+      -0.01725439541041851,
+      -0.023210182785987854,
+      0.0214429572224617,
+      0.08773590624332428,
+      0.02890642359852791,
+      0.05008307844400406,
+      0.0386715866625309,
+      0.05411011353135109,
+      -0.030319014564156532,
+      0.06525710225105286,
+      -0.034479085355997086,
+      0.021844418719410896,
+      -0.029367344453930855,
+      0.025703189894557,
+      0.10176338255405426,
+      -0.07165675610303879,
+      -0.007929731160402298,
+      0.03543964773416519,
+      -0.03774898499250412,
+      -0.06231209263205528,
+      -0.047276586294174194,
+      -0.029912583529949188,
+      0.014294497668743134,
+      -0.08385027199983597,
+      -0.000271238706773147,
+      0.006358132231980562,
+      0.014557887800037861,
+      0.010368247516453266,
+      -0.04932534322142601,
+      -0.03402839973568916,
+      -0.04656204581260681,
+      0.07528579980134964,
+      0.05115582421422005,
+      -0.0008488013409078121,
+      -0.04342127963900566,
+      0.0033140804152935743,
+      0.002237041015177965,
+      0.008954676799476147,
+      -0.020682206377387047,
+      -0.012842242605984211,
+      -0.060310740023851395,
+      0.015884054824709892,
+      0.03775676712393761,
+      0.015396155416965485,
+      0.08170188218355179,
+      0.07413624972105026,
+      0.018573077395558357,
+      -0.07058368623256683,
+      -0.006621289532631636,
+      -0.0138900401070714,
+      -0.06558379530906677,
+      -0.011528769508004189,
+      0.09618879854679108,
+      0.07202176004648209,
+      0.0008702993509359658,
+      -0.01355170551687479,
+      -0.008986256085336208,
+      0.0859515517950058,
+      0.05258339270949364,
+      -0.09769712388515472,
+      0.004891761112958193,
+      0.03664194419980049,
+      -0.10887455940246582,
+      0.09263604134321213
+    ],
+    "importance": 0.5
+  }
+]

memories/timeline.md

@@ -0,0 +1,7 @@
+# Memory Timeline
+
+## 2026-01-09
+
+- **Conversation** (22:26:39): User mentioned: User shared their name. Details: my name is edwin
+- **Conversation** (22:25:17): User mentioned: User shared their name. Details: hello my name is edwin mauricio
+

memory_manager.py

@@ -0,0 +1,229 @@
+import json
+import os
+import time
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
+from rich.console import Console
+
+console = Console()
+
+class MemoryManager:
+    """Manages user memories using vector embeddings and FAISS for efficient retrieval."""
+
+    def __init__(self, memory_dir: str = "memories"):
+        """
+        Initialize the memory manager.
+
+        Args:
+            memory_dir: Directory to store memory files
+        """
+        self.memory_dir = memory_dir
+        self.memories_file = os.path.join(memory_dir, "memories.json")
+        self.timeline_file = os.path.join(memory_dir, "timeline.md")
+
+        # Create memory directory if it doesn't exist
+        os.makedirs(memory_dir, exist_ok=True)
+
+        # Initialize sentence transformer for embeddings
+        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
+
+        # Load existing memories or create empty list
+        self.memories = self._load_memories()
+
+        # Initialize FAISS index
+        self.dimension = 384  # Dimension of MiniLM embeddings
+        self.index = faiss.IndexFlatL2(self.dimension)
+        self._build_index()
+
+    def _load_memories(self) -> List[Dict]:
+        """Load memories from JSON file."""
+        if os.path.exists(self.memories_file):
+            try:
+                with open(self.memories_file, 'r') as f:
+                    return json.load(f)
+            except Exception as e:
+                console.print(f"[red]Error loading memories: {e}[/red]")
+                return []
+        return []
+
+    def _save_memories(self):
+        """Save memories to JSON file."""
+        try:
+            with open(self.memories_file, 'w') as f:
+                json.dump(self.memories, f, indent=2)
+        except Exception as e:
+            console.print(f"[red]Error saving memories: {e}[/red]")
+
+    def _build_index(self):
+        """Build FAISS index from existing memories."""
+        if self.memories:
+            embeddings = []
+            for memory in self.memories:
+                if 'embedding' in memory:
+                    embeddings.append(np.array(memory['embedding'], dtype='float32'))
+
+            if embeddings:
+                embeddings = np.array(embeddings)
+                self.index.add(embeddings)
+
+    def add_memory(self, content: str, context: str = "", memory_type: str = "general") -> Dict:
+        """
+        Add a new memory to the memory store.
+
+        Args:
+            content: The main content of the memory
+            context: Additional context about when/where this occurred
+            memory_type: Type of memory (general, fact, preference, etc.)
+
+        Returns:
+            The created memory object
+        """
+        # Create embedding for the memory
+        embedding = self.embedder.encode(content).astype('float32')
+
+        # Create memory object
+        memory = {
+            "id": len(self.memories) + 1,
+            "content": content,
+            "context": context,
+            "type": memory_type,
+            "timestamp": datetime.now().isoformat(),
+            "embedding": embedding.tolist(),
+            "importance": self._calculate_importance(content)
+        }
+
+        # Add to memories list
+        self.memories.append(memory)
+
+        # Add to FAISS index
+        self.index.add(embedding.reshape(1, -1))
+
+        # Save to file
+        self._save_memories()
+
+        # Update timeline
+        self._update_timeline()
+
+        console.print(f"[green]✓ Memory added: {content[:50]}...[/green]")
+        return memory
+
+    def _calculate_importance(self, content: str) -> float:
+        """
+        Calculate the importance score of a memory based on its content.
+
+        Args:
+            content: The memory content
+
+        Returns:
+            Importance score between 0 and 1
+        """
+        # Simple importance calculation based on content length and keywords
+        importance = 0.5  # Base importance
+
+        # Keywords that indicate higher importance
+        important_keywords = [
+            "love", "family", "important", "urgent", "must", "remember",
+            "birthday", "anniversary", "special", "favorite", "hate",
+            "never", "always", "often", "every", "daily", "weekly"
+        ]
+
+        content_lower = content.lower()
+        for keyword in important_keywords:
+            if keyword in content_lower:
+                importance += 0.1
+
+        # Longer memories might be more important
+        if len(content) > 100:
+            importance += 0.1
+
+        return min(importance, 1.0)
+
+    def retrieve_memories(self, query: str, k: int = 5) -> List[Dict]:
+        """
+        Retrieve relevant memories based on a query.
+
+        Args:
+            query: The search query
+            k: Number of memories to retrieve
+
+        Returns:
+            List of relevant memories sorted by relevance
+        """
+        if not self.memories:
+            return []
+
+        # Create embedding for the query
+        query_embedding = self.embedder.encode(query).astype('float32')
+
+        # Search in FAISS index
+        distances, indices = self.index.search(query_embedding.reshape(1, -1), k)
+
+        # Get the memories
+        relevant_memories = []
+        for i, idx in enumerate(indices[0]):
+            if idx < len(self.memories):
+                memory = self.memories[idx]
+                memory['relevance_score'] = float(distances[0][i])
+                relevant_memories.append(memory)
+
+        # Sort by relevance (lower distance = more relevant)
+        relevant_memories.sort(key=lambda x: x['relevance_score'])
+
+        return relevant_memories
+
+    def get_recent_memories(self, limit: int = 10) -> List[Dict]:
+        """Get the most recent memories."""
+        return sorted(self.memories, key=lambda x: x['timestamp'], reverse=True)[:limit]
+
+    def get_memory_types(self) -> Dict[str, int]:
+        """Get statistics about memory types."""
+        type_counts = {}
+        for memory in self.memories:
+            memory_type = memory.get('type', 'general')
+            type_counts[memory_type] = type_counts.get(memory_type, 0) + 1
+        return type_counts
+
+    def _update_timeline(self):
+        """Update the human-readable timeline file."""
+        timeline_content = "# Memory Timeline\n\n"
+
+        # Group memories by date
+        memories_by_date = {}
+        for memory in sorted(self.memories, key=lambda x: x['timestamp'], reverse=True):
+            date = memory['timestamp'][:10]  # YYYY-MM-DD
+            if date not in memories_by_date:
+                memories_by_date[date] = []
+            memories_by_date[date].append(memory)
+
+        # Build timeline
+        for date in sorted(memories_by_date.keys(), reverse=True):
+            timeline_content += f"## {date}\n\n"
+            for memory in memories_by_date[date]:
+                timeline_content += f"- **{memory['type'].title()}** ({memory['timestamp'][11:19]}): {memory['content']}\n"
+            timeline_content += "\n"
+
+        try:
+            with open(self.timeline_file, 'w') as f:
+                f.write(timeline_content)
+        except Exception as e:
+            console.print(f"[red]Error updating timeline: {e}[/red]")
+
+    def get_summary(self) -> Dict:
+        """Get a summary of the memory store."""
+        return {
+            "total_memories": len(self.memories),
+            "memory_types": self.get_memory_types(),
+            "recent_memories": self.get_recent_memories(5),
+            "timeline_file": self.timeline_file
+        }
+
+    def clear_memories(self):
+        """Clear all memories."""
+        self.memories = []
+        self.index = faiss.IndexFlatL2(self.dimension)
+        self._save_memories()
+        self._update_timeline()
+        console.print("[yellow]All memories cleared.[/yellow]")

quick_git_deploy.sh

@@ -0,0 +1,109 @@
+#!/bin/bash
+
+# Quick Git Deployment to Hugging Face Spaces
+# Run this script to deploy your Memory Chat application
+
+echo "🚀 Memory Chat - Quick Git Deployment to Hugging Face Spaces"
+echo "=============================================================="
+
+# Check if git is installed
+if ! command -v git &> /dev/null; then
+    echo "❌ Git is not installed. Please install Git first."
+    exit 1
+fi
+
+# Check if required files exist
+required_files=("app.py" "memory_manager.py" "chat_interface.py" "config.py" "requirements.txt" "README.md")
+for file in "${required_files[@]}"; do
+    if [ ! -f "$file" ]; then
+        echo "❌ Missing file: $file"
+        echo "Please ensure all required files are in the current directory."
+        exit 1
+    fi
+done
+
+echo "✅ All required files found"
+
+# Get user input
+read -p "Enter your Hugging Face username: " username
+read -p "Enter your Space name (e.g., memory-chat): " space_name
+
+# Check if this is a new Space or existing
+echo ""
+echo "Is this a new Space? (y/n)"
+read -p "Choice [y/n]: " new_space
+
+if [ "$new_space" = "y" ] || [ "$new_space" = "Y" ]; then
+    echo ""
+    echo "🌐 Creating new Space..."
+    echo "Please create your Space at: https://huggingface.co/spaces/new"
+    echo ""
+    echo "Space details:"
+    echo "- Name: $space_name"
+    echo "- Type: Gradio"
+    echo "- Visibility: Public"
+    echo ""
+    echo "After creating the Space, press Enter to continue..."
+    read
+fi
+
+# Setup Git
+echo ""
+echo "🔧 Setting up Git repository..."
+
+# Initialize if not already
+if [ ! -d ".git" ]; then
+    git init
+fi
+
+# Get Hugging Face token
+echo ""
+echo "🔐 Getting Hugging Face credentials..."
+echo "Please get your Hugging Face API token:"
+echo "1. Go to: https://huggingface.co/settings/tokens"
+echo "2. Click 'New token'"
+echo "3. Set name: 'spaces-deploy'"
+echo "4. Set role: 'write'"
+echo "5. Copy the token"
+echo ""
+read -s -p "Enter your Hugging Face API token: " hf_token
+echo ""
+
+# Setup remote URL
+remote_url="https://$username:$hf_token@huggingface.co/spaces/$username/$space_name"
+
+# Remove existing remote if exists
+git remote remove origin 2>/dev/null || true
+
+# Add remote
+git remote add origin "$remote_url"
+echo "✅ Git remote configured"
+
+# Add files and commit
+echo ""
+echo "📁 Preparing files..."
+git add .
+git commit -m "Initial commit: Memory Chat application"
+echo "✅ Files committed"
+
+# Push to Hugging Face
+echo ""
+echo "🚀 Deploying to Hugging Face Spaces..."
+if git push -u origin main; then
+    echo ""
+    echo "🎉 Successfully deployed!"
+    echo "🌐 Your Space: https://huggingface.co/spaces/$username/$space_name"
+    echo ""
+    echo "💡 Check the 'Logs' tab in your Space for build progress."
+    echo "💡 Your Space should be live in 3-5 minutes."
+else
+    echo "❌ Deployment failed. Trying force push..."
+    if git push -u origin main --force; then
+        echo ""
+        echo "🎉 Successfully deployed (force push)!"
+        echo "🌐 Your Space: https://huggingface.co/spaces/$username/$space_name"
+    else
+        echo "❌ Failed to deploy. Please check your credentials and try again."
+        exit 1
+    fi
+fi

requirements.txt

@@ -0,0 +1,15 @@
+# Core dependencies
+torch>=2.0.0
+transformers>=4.30.0
+gradio>=3.50.0
+langchain>=0.0.300
+
+# Memory and data processing
+faiss-cpu>=1.7.0
+sentence-transformers>=2.2.0
+numpy>=1.21.0
+pandas>=1.5.0
+
+# Utilities
+python-dotenv>=1.0.0
+rich>=13.0.0

space_app.py

@@ -0,0 +1,323 @@
+"""
+Hugging Face Spaces version of the Memory Chat application.
+Optimized for the HF Spaces environment with persistent storage.
+"""
+
+import os
+import gradio as gr
+from memory_manager import MemoryManager
+from chat_interface import HuggingFaceChat
+from rich.console import Console
+
+console = Console()
+
+class HFSpaceApp:
+    """Hugging Face Spaces version of the Memory Chat application."""
+
+    def __init__(self):
+        """Initialize the Spaces application."""
+        # Use persistent storage on HF Spaces
+        self.memory_dir = "/tmp/memories" if os.getenv("SPACE_ID") else "memories"
+        os.makedirs(self.memory_dir, exist_ok=True)
+
+        self.memory_manager = MemoryManager(self.memory_dir)
+        self.chat_interface = HuggingFaceChat()
+
+        # Conversation history
+        self.conversation_history = []
+
+        # Load existing memories
+        summary = self.memory_manager.get_summary()
+        console.print(f"[blue]Loaded {summary['total_memories']} memories[/blue]")
+
+    def should_record_memory(self, user_input: str, ai_response: str) -> bool:
+        """Determine if the conversation should be recorded as a memory."""
+        important_keywords = [
+            "remember", "important", "note", "fact", "detail", "information",
+            "love", "hate", "like", "dislike", "favorite", "never", "always",
+            "birthday", "anniversary", "special", "urgent", "must", "should"
+        ]
+
+        combined_text = f"{user_input} {ai_response}".lower()
+
+        for keyword in important_keywords:
+            if keyword in combined_text:
+                return True
+
+        personal_patterns = [
+            "my name is", "i live in", "i work at", "i study", "my birthday",
+            "my favorite", "i love", "i hate", "i like", "i dislike"
+        ]
+
+        for pattern in personal_patterns:
+            if pattern in combined_text:
+                return True
+
+        return False
+
+    def extract_memory_content(self, user_input: str, ai_response: str) -> str:
+        """Extract the most important information to store as a memory."""
+        if any(word in user_input.lower() for word in ["remember", "note", "save"]):
+            return user_input
+
+        personal_info = []
+        if "my name is" in user_input.lower():
+            personal_info.append("User shared their name")
+        if "i live in" in user_input.lower():
+            personal_info.append("User shared their location")
+        if "i work at" in user_input.lower():
+            personal_info.append("User shared their workplace")
+        if "i study" in user_input.lower():
+            personal_info.append("User shared their studies")
+        if "my birthday" in user_input.lower():
+            personal_info.append("User shared their birthday")
+        if "my favorite" in user_input.lower():
+            personal_info.append("User shared a favorite thing")
+
+        if personal_info:
+            return f"User mentioned: {', '.join(personal_info)}. Details: {user_input}"
+
+        return user_input
+
+    def chat_with_memory(self, user_input: str) -> str:
+        """Chat with the AI while managing memories."""
+        if not self.chat_interface.check_model_availability():
+            return "I'm sorry, but I couldn't load the AI model. Please check your internet connection."
+
+        self.conversation_history.append({"role": "user", "content": user_input})
+
+        relevant_memories = self.memory_manager.retrieve_memories(user_input, k=3)
+
+        context = ""
+        if relevant_memories:
+            context = "Relevant memories:\n"
+            for memory in relevant_memories[:2]:
+                context += f"- {memory['content']}\n"
+            context += "\n"
+
+        prompt = self.build_prompt(user_input, context)
+        ai_response = self.chat_interface.generate_response(prompt)
+
+        self.conversation_history.append({"role": "assistant", "content": ai_response})
+
+        if self.should_record_memory(user_input, ai_response):
+            memory_content = self.extract_memory_content(user_input, ai_response)
+            context_info = f"During conversation at {self.get_current_time()}"
+
+            self.memory_manager.add_memory(
+                content=memory_content,
+                context=context_info,
+                memory_type="conversation"
+            )
+
+        return ai_response
+
+    def build_prompt(self, user_input: str, context: str) -> str:
+        """Build the prompt for the AI model."""
+        prompt = f"{context}Human: {user_input}\nAI: "
+        return prompt
+
+    def get_current_time(self) -> str:
+        """Get current time in a readable format."""
+        import datetime
+        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    def get_memories_summary(self) -> str:
+        """Get a summary of stored memories."""
+        summary = self.memory_manager.get_summary()
+        memory_types = summary['memory_types']
+
+        summary_text = f"""
+## Memory Summary
+
+**Total Memories:** {summary['total_memories']}
+
+**Memory Types:**
+"""
+        for memory_type, count in memory_types.items():
+            summary_text += f"- {memory_type}: {count}\n"
+
+        return summary_text
+
+    def get_recent_memories(self) -> str:
+        """Get the most recent memories."""
+        recent_memories = self.memory_manager.get_recent_memories()
+        if not recent_memories:
+            return "No memories stored yet."
+
+        memory_text = "## Recent Memories\n\n"
+        for memory in recent_memories:
+            memory_text += f"**{memory['type'].title()}** ({memory['timestamp'][:19]}):\n"
+            memory_text += f"{memory['content']}\n\n"
+
+        return memory_text
+
+    def clear_all_memories(self) -> str:
+        """Clear all memories."""
+        self.memory_manager.clear_memories()
+        return "All memories have been cleared."
+
+    def get_model_info(self) -> str:
+        """Get information about the AI model."""
+        info = self.chat_interface.get_model_info()
+        return f"""
+## Model Information
+
+**Model:** {info['model_name']}
+**Device:** {info['device']}
+**Available:** {'Yes' if info['available'] else 'No'}
+"""
+
+    def run_gradio_interface(self):
+        """Run the Gradio interface optimized for HF Spaces."""
+        # Custom CSS for better appearance on Spaces
+        css = """
+        .gradio-container {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+        .gr-prose h1 {
+            text-align: center;
+            color: #1f2937;
+        }
+        .gr-prose h2 {
+            color: #374151;
+        }
+        """
+
+        with gr.Blocks(title="Memory Chat - Hugging Face Spaces", css=css, theme=gr.themes.Soft()) as demo:
+            gr.Markdown("# 🤖 Memory Chat with Hugging Face")
+            gr.Markdown("### Chat with an AI that remembers important details about you!")
+
+            with gr.Tab("💬 Chat"):
+                chatbot = gr.Chatbot(height=500)
+                with gr.Row():
+                    msg = gr.Textbox(
+                        label="Your Message",
+                        placeholder="Type your message here...",
+                        scale=4
+                    )
+                    submit_btn = gr.Button("Send", scale=1)
+
+                with gr.Row():
+                    clear_btn = gr.Button("Clear Conversation")
+                    clear_memories_btn = gr.Button("Clear All Memories", variant="stop")
+
+                # Submit on Enter key
+                msg.submit(
+                    fn=self.user,
+                    inputs=[msg, chatbot],
+                    outputs=[msg, chatbot],
+                    queue=False
+                )
+
+                submit_btn.click(
+                    fn=self.user,
+                    inputs=[msg, chatbot],
+                    outputs=[msg, chatbot],
+                    queue=False
+                )
+
+                clear_btn.click(
+                    fn=self.clear_history,
+                    inputs=None,
+                    outputs=chatbot,
+                    queue=False
+                )
+
+                clear_memories_btn.click(
+                    fn=lambda: (self.clear_all_memories(), None),
+                    inputs=None,
+                    outputs=[gr.Textbox(), chatbot],
+                    queue=False
+                )
+
+            with gr.Tab("📚 Memories"):
+                memories_summary = gr.Markdown(value=self.get_memories_summary())
+                recent_memories = gr.Markdown(value=self.get_recent_memories())
+
+                with gr.Row():
+                    refresh_btn = gr.Button("Refresh Memories")
+                    timeline_link = gr.Markdown(f"[View Timeline]({self.memory_manager.timeline_file})")
+
+                refresh_btn.click(
+                    fn=lambda: (self.get_memories_summary(), self.get_recent_memories()),
+                    inputs=None,
+                    outputs=[memories_summary, recent_memories],
+                    queue=False
+                )
+
+            with gr.Tab("🤖 Model Info"):
+                model_info = gr.Markdown(value=self.get_model_info())
+
+            with gr.Tab("ℹ️ About"):
+                gr.Markdown("""
+                ## About This Application
+
+                This application combines Hugging Face AI models with a memory system that records important information from your conversations.
+
+                ### Features:
+                - 🤖 Chat with Hugging Face models
+                - 💾 Automatic memory recording
+                - 📚 View and manage your memories
+                - 🔍 Search through your memories
+
+                ### How it works:
+                1. Have a conversation with the AI
+                2. The system automatically detects important information
+                3. Important memories are stored and can be recalled in future conversations
+                4. View your memory timeline and statistics
+
+                ### Memory Types:
+                - **General**: General information and facts
+                - **Conversation**: Important details from chats
+                - **Preferences**: Likes, dislikes, favorites
+                - **Important**: Critical information marked as important
+
+                ---
+                **Note**: Memories are stored locally and persist between sessions on this Space.
+                """)
+
+        return demo
+
+    def user(self, user_message, history):
+        """Handle user input and generate AI response."""
+        if not user_message.strip():
+            return "", history
+
+        ai_response = self.chat_with_memory(user_message)
+
+        if history is None:
+            history = []
+        history.append({"role": "user", "content": user_message})
+        history.append({"role": "assistant", "content": ai_response})
+
+        return "", history
+
+    def clear_history(self):
+        """Clear conversation history."""
+        self.conversation_history = []
+        return None
+
+    def clear_all_memories(self) -> str:
+        """Clear all memories."""
+        self.memory_manager.clear_memories()
+        return "All memories have been cleared."
+
+def main():
+    """Main entry point for HF Spaces."""
+    console.print("[green]🚀 Starting Memory Chat Application for HF Spaces...[/green]")
+
+    # Create and run the application
+    app = HFSpaceApp()
+
+    # Run Gradio interface optimized for Spaces
+    demo = app.run_gradio_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        debug=False,
+        show_error=True
+    )
+
+if __name__ == "__main__":
+    main()

space_requirements.txt

@@ -0,0 +1,25 @@
+# Hugging Face Spaces Requirements
+# Optimized for the Spaces environment
+
+# Core dependencies
+torch>=2.0.0
+transformers>=4.30.0
+gradio>=4.0.0
+
+# Memory and data processing
+faiss-cpu>=1.7.0
+sentence-transformers>=2.2.0
+numpy>=1.21.0
+pandas>=1.5.0
+
+# Utilities
+python-dotenv>=1.0.0
+rich>=13.0.0
+
+# Additional dependencies for better Spaces performance
+pillow>=9.0.0
+scikit-learn>=1.0.0
+joblib>=1.0.0
+
+# For HF Spaces specific optimizations
+huggingface_hub>=0.15.0

test_app.py

@@ -0,0 +1,116 @@
+"""
+Test script to verify the Memory Chat application works correctly.
+"""
+
+import sys
+import os
+
+# Add the project directory to the Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+def test_memory_manager():
+    """Test the memory manager functionality."""
+    print("Testing Memory Manager...")
+
+    from memory_manager import MemoryManager
+
+    # Create a test memory manager
+    mm = MemoryManager("test_memories")
+
+    # Test adding a memory
+    memory = mm.add_memory(
+        content="I love pizza and hate mushrooms",
+        context="Testing memory recording",
+        memory_type="preference"
+    )
+
+    print(f"Added memory: {memory['content']}")
+    print(f"Memory ID: {memory['id']}")
+
+    # Test retrieving memories
+    relevant = mm.retrieve_memories("What do I like to eat?")
+    print(f"Found {len(relevant)} relevant memories")
+
+    # Test summary
+    summary = mm.get_summary()
+    print(f"Total memories: {summary['total_memories']}")
+    print(f"Memory types: {summary['memory_types']}")
+
+    # Test timeline
+    print(f"Timeline file: {mm.timeline_file}")
+
+    print("✓ Memory Manager tests passed!")
+    return True
+
+def test_chat_interface():
+    """Test the chat interface functionality."""
+    print("\nTesting Chat Interface...")
+
+    from chat_interface import HuggingFaceChat
+
+    # Create a test chat interface
+    chat = HuggingFaceChat(model_name="microsoft/DialoGPT-small")
+
+    # Test model info
+    info = chat.get_model_info()
+    print(f"Model: {info['model_name']}")
+    print(f"Device: {info['device']}")
+    print(f"Available: {info['available']}")
+
+    if info['available']:
+        # Test generating a response
+        response = chat.generate_response("Hello, how are you?", max_length=50)
+        print(f"Generated response: {response[:50]}...")
+        print("✓ Chat Interface tests passed!")
+    else:
+        print("⚠ Model not available - skipping response generation test")
+
+    return True
+
+def test_main_app():
+    """Test the main application functionality."""
+    print("\nTesting Main Application...")
+
+    from app import MemoryChatApp
+
+    # Create the main app
+    app = MemoryChatApp()
+
+    # Test memory recording logic
+    should_record = app.should_record_memory(
+        "Remember that I love pizza and hate mushrooms",
+        "I'll remember that you love pizza and hate mushrooms"
+    )
+    print(f"Should record memory: {should_record}")
+
+    # Test memory extraction
+    content = app.extract_memory_content(
+        "My name is John and I live in New York",
+        "Nice to meet you, John!"
+    )
+    print(f"Extracted content: {content}")
+
+    print("✓ Main Application tests passed!")
+    return True
+
+def main():
+    """Run all tests."""
+    print("🧪 Running Memory Chat Application Tests\n")
+
+    try:
+        test_memory_manager()
+        test_chat_interface()
+        test_main_app()
+
+        print("\n🎉 All tests passed successfully!")
+        print("\nTo run the application, use:")
+        print("python app.py")
+
+    except Exception as e:
+        print(f"\n❌ Test failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    main()

test_memories/memories.json

@@ -0,0 +1,396 @@
+[
+  {
+    "id": 1,
+    "content": "I love pizza and hate mushrooms",
+    "context": "Testing memory recording",
+    "type": "preference",
+    "timestamp": "2026-01-09T22:17:32.310198",
+    "embedding": [
+      0.03875897452235222,
+      0.05280157923698425,
+      -0.0036089224740862846,
+      0.03695211187005043,
+      -0.023045089095830917,
+      -0.03902852535247803,
+      0.009436762891709805,
+      0.0346154123544693,
+      0.043741531670093536,
+      -0.04868815094232559,
+      -0.006189689971506596,
+      -0.11021631956100464,
+      -0.009066620841622353,
+      -0.0006522072362713516,
+      -0.027590803802013397,
+      -0.09565330296754837,
+      0.10817263275384903,
+      0.01229641493409872,
+      0.009932232089340687,
+      0.026499642059206963,
+      -0.12098328024148941,
+      0.0022552867885679007,
+      0.012434019707143307,
+      0.055118389427661896,
+      -0.002861551707610488,
+      0.03585321083664894,
+      0.05726490169763565,
+      -0.005705655552446842,
+      -0.09828298538923264,
+      -0.07979002594947815,
+      -0.024431949481368065,
+      0.04378493130207062,
+      0.03211062401533127,
+      0.02371874824166298,
+      0.006798949558287859,
+      0.027640240266919136,
+      0.044980160892009735,
+      -0.021570760756731033,
+      0.010082061402499676,
+      -0.01285412348806858,
+      0.006022365763783455,
+      -0.016429850831627846,
+      0.10763106495141983,
+      -0.03610154241323471,
+      -0.04212067276239395,
+      -0.020476410165429115,
+      -0.05501566454768181,
+      -0.04217110574245453,
+      0.08153433352708817,
+      -0.0022776515688747168,
+      -0.006549549754709005,
+      -0.04484741389751434,
+      0.0019414419075474143,
+      0.009914860129356384,
+      0.06342000514268875,
+      0.03797575831413269,
+      0.0017721757758408785,
+      0.07385660707950592,
+      0.030930178239941597,
+      0.005188942886888981,
+      -0.05744442343711853,
+      -0.028558610007166862,
+      -0.02010233886539936,
+      0.022334858775138855,
+      -0.03946618363261223,
+      0.017596201971173286,
+      0.013011138886213303,
+      -0.034720975905656815,
+      -0.11083326488733292,
+      0.029160676524043083,
+      -0.06863938271999359,
+      0.14139509201049805,
+      0.04009837657213211,
+      0.0042649307288229465,
+      0.03515723720192909,
+      0.05172161012887955,
+      -0.07069050520658493,
+      -0.11678112298250198,
+      -0.016300832852721214,
+      -0.00355102913454175,
+      0.006738871801644564,
+      0.039899792522192,
+      -0.07166972756385803,
+      -0.03614625334739685,
+      0.007328942883759737,
+      -0.04860224947333336,
+      -0.036764100193977356,
+      0.0898534506559372,
+      -0.007359549403190613,
+      -0.037999823689460754,
+      0.04665827751159668,
+      0.016000930219888687,
+      -0.015914632007479668,
+      0.03706985339522362,
+      -0.1284528225660324,
+      -0.007612523157149553,
+      0.04461376368999481,
+      -0.017212973907589912,
+      -0.0577964149415493,
+      0.02981126308441162,
+      0.043312132358551025,
+      0.0226021446287632,
+      0.0028474382124841213,
+      -0.015525512397289276,
+      -0.0015342201804742217,
+      -0.005015364848077297,
+      -0.017388317734003067,
+      0.014934140257537365,
+      0.021618826314806938,
+      -0.01472227182239294,
+      -0.06851861625909805,
+      -0.020711563527584076,
+      -0.006072571501135826,
+      -0.10369426757097244,
+      -0.04529580473899841,
+      0.036348480731248856,
+      0.17342831194400787,
+      -0.01117977499961853,
+      -0.002181128365918994,
+      -0.06905186176300049,
+      -0.06843563914299011,
+      0.055621787905693054,
+      -0.0016529976855963469,
+      0.013280079700052738,
+      -0.00802586693316698,
+      -0.03741363435983658,
+      -0.05268894508481026,
+      -4.075902867227461e-33,
+      0.006541554816067219,
+      -0.03750442713499069,
+      0.004569194279611111,
+      0.028262028470635414,
+      0.09822557121515274,
+      0.023845698684453964,
+      0.034406550228595734,
+      -0.026209214702248573,
+      -0.0019082747166976333,
+      -0.048137374222278595,
+      -0.04675827547907829,
+      -0.014687173999845982,
+      -0.09685590118169785,
+      0.04304314777255058,
+      0.0956728532910347,
+      -0.03698369860649109,
+      0.01719755493104458,
+      -0.01942829042673111,
+      -0.03239534795284271,
+      0.005671426188200712,
+      -0.03917429968714714,
+      -0.052515964955091476,
+      0.004365224856883287,
+      0.07336638122797012,
+      0.023350490257143974,
+      -0.00924033671617508,
+      0.006770065054297447,
+      -0.06278658658266068,
+      -0.07000599056482315,
+      0.027859432622790337,
+      0.047039907425642014,
+      0.07487046718597412,
+      -0.03225914016366005,
+      0.03604402393102646,
+      0.06695506721735,
+      0.0010574770858511329,
+      -0.02069864422082901,
+      0.04274166002869606,
+      -0.04989098757505417,
+      0.004137680400162935,
+      -0.00025893194833770394,
+      0.008062557317316532,
+      -0.01318787969648838,
+      -0.00031607673736289144,
+      0.05711536854505539,
+      -0.0007494656601920724,
+      0.060785844922065735,
+      0.05949707329273224,
+      0.024985065683722496,
+      0.01749240607023239,
+      0.043190713971853256,
+      0.0016048630932345986,
+      0.0659165307879448,
+      0.06616315990686417,
+      0.004274787846952677,
+      -0.020389487966895103,
+      -0.00022031544358469546,
+      0.006546191405504942,
+      -0.0802990049123764,
+      -0.015048844739794731,
+      0.0018401734996587038,
+      0.17213928699493408,
+      -0.005646882578730583,
+      0.029732992872595787,
+      -0.06042931601405144,
+      0.023296164348721504,
+      -0.054148390889167786,
+      0.01718498207628727,
+      -0.012741944752633572,
+      -0.023687368258833885,
+      0.06259965151548386,
+      -0.029198691248893738,
+      -0.035791460424661636,
+      -0.006957892794162035,
+      -0.027986085042357445,
+      -0.04067635536193848,
+      -0.027017366141080856,
+      -0.02490904927253723,
+      0.001286563347093761,
+      -0.04923729971051216,
+      0.12612949311733246,
+      -0.06118234619498253,
+      0.025343816727399826,
+      -0.09424808621406555,
+      -0.050376296043395996,
+      0.018575582653284073,
+      0.040960460901260376,
+      -0.08399675786495209,
+      0.06317627429962158,
+      -0.008798257447779179,
+      -0.02382872812449932,
+      -0.10085533559322357,
+      0.06266158074140549,
+      -0.005287562496960163,
+      -0.07304846495389938,
+      2.6339689464668783e-33,
+      0.02700074017047882,
+      -0.03891989216208458,
+      0.0906137153506279,
+      0.002930642571300268,
+      -0.05978973209857941,
+      -0.03640030324459076,
+      -0.08346077799797058,
+      -0.03455350920557976,
+      0.010466857813298702,
+      -0.018092645332217216,
+      -0.010924994945526123,
+      -0.0056700324639678,
+      0.009872970171272755,
+      0.004627453163266182,
+      0.039202407002449036,
+      0.023374829441308975,
+      0.007121958304196596,
+      0.03754819184541702,
+      0.002887109061703086,
+      -0.048984918743371964,
+      -0.06600604206323624,
+      0.024129414930939674,
+      -0.10960401594638824,
+      0.09468576312065125,
+      0.010289560072124004,
+      0.036206286400556564,
+      0.03706667199730873,
+      0.03738970682024956,
+      -0.005809256341308355,
+      -0.014523929916322231,
+      -0.026120955124497414,
+      0.04401257634162903,
+      -0.06476949155330658,
+      -0.09099779278039932,
+      0.026981577277183533,
+      0.007235502824187279,
+      -0.09973607957363129,
+      -0.010897793807089329,
+      0.046681635081768036,
+      -0.007838481105864048,
+      -0.06591387838125229,
+      0.002104088431224227,
+      0.034640826284885406,
+      0.07849340885877609,
+      0.019736697897315025,
+      0.03956855088472366,
+      0.06556658446788788,
+      -0.07211563736200333,
+      -0.01375817134976387,
+      -0.003739030798897147,
+      -0.07897455245256424,
+      0.011246136389672756,
+      0.01158884260803461,
+      0.014312366023659706,
+      0.0849107950925827,
+      -0.0038072494789958,
+      -0.019378235563635826,
+      0.021105559542775154,
+      -0.027357321232557297,
+      -0.15211528539657593,
+      -0.06424858421087265,
+      0.045168593525886536,
+      -0.05706986039876938,
+      0.09536726027727127,
+      0.06616023927927017,
+      0.034766655415296555,
+      0.01604684814810753,
+      -0.10831272602081299,
+      0.009145919233560562,
+      0.014202374964952469,
+      0.013556702062487602,
+      0.014952413737773895,
+      -0.022692520171403885,
+      0.045712269842624664,
+      -0.03190644457936287,
+      -0.11130636185407639,
+      -0.0584193654358387,
+      0.09788035601377487,
+      -0.02719079703092575,
+      0.033073607832193375,
+      0.04209985211491585,
+      -3.836547693936154e-05,
+      0.0006786540616303682,
+      0.017447445541620255,
+      -0.016584279015660286,
+      -0.05588225647807121,
+      0.014428879134356976,
+      -0.005860479082912207,
+      -0.1216338574886322,
+      0.042214371263980865,
+      0.031251199543476105,
+      0.06258829683065414,
+      -0.00560770696029067,
+      0.009469529613852501,
+      0.13937869668006897,
+      -1.4204578846488403e-08,
+      0.08057358860969543,
+      -0.046007029712200165,
+      -0.033160291612148285,
+      -0.030236952006816864,
+      0.0028210626915097237,
+      -0.05327284336090088,
+      0.01176622323691845,
+      0.05292908474802971,
+      -0.004327722359448671,
+      0.01068241335451603,
+      -0.025575213134288788,
+      0.13546429574489594,
+      -0.011062612757086754,
+      0.0798792764544487,
+      0.013184454292058945,
+      0.05832760035991669,
+      0.08903287351131439,
+      -0.07126083970069885,
+      0.0015069111250340939,
+      0.11210285127162933,
+      -0.06859140843153,
+      0.0007342977914959192,
+      0.008753067813813686,
+      -0.03712032362818718,
+      -0.03303607553243637,
+      -0.011919373646378517,
+      0.06076401099562645,
+      -0.04716166853904724,
+      0.11556678265333176,
+      0.08400286734104156,
+      0.011252880096435547,
+      -0.01946060173213482,
+      -0.027820004150271416,
+      0.0015117272268980742,
+      0.0003631317522376776,
+      -0.001311573782004416,
+      -0.029412981122732162,
+      -0.06827309727668762,
+      0.03195794299244881,
+      -0.04242730513215065,
+      -0.04463118687272072,
+      -0.03493130952119827,
+      -0.027541792020201683,
+      -0.03074466437101364,
+      -0.11165875941514969,
+      -0.014854801818728447,
+      -0.015592128038406372,
+      0.005249170586466789,
+      -0.0552591010928154,
+      0.0578744001686573,
+      0.046071503311395645,
+      0.06435728073120117,
+      0.05426222085952759,
+      0.03952239081263542,
+      0.057633351534605026,
+      -0.006186990067362785,
+      0.09624188393354416,
+      0.07667811959981918,
+      0.03082921728491783,
+      0.025117972865700722,
+      0.048737410455942154,
+      0.05643203482031822,
+      0.06902598589658737,
+      -0.05484015494585037
+    ],
+    "importance": 0.7
+  }
+]

test_memories/timeline.md

@@ -0,0 +1,6 @@
+# Memory Timeline
+
+## 2026-01-09
+
+- **Preference** (22:17:32): I love pizza and hate mushrooms
+