Upload 4 files

README.md

@@ -1,12 +1,184 @@
----
-title: NLPWMAD
-emoji: 📉
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# AI Assistant - Gradio Web Application
+
+A comprehensive AI Assistant built with Gradio that combines chat functionality, notes management, reminders, document processing, and system monitoring in a single web interface.
+
+## 🚀 Features
+
+- **💬 Smart Chat**: Intelligent conversations with AI assistance
+- **📝 Notes Management**: Create, edit, and organize your notes
+- **⏰ Reminders**: Set and manage time-based notifications
+- **📄 Document Processing**: Upload and analyze PDF, TXT, and Markdown files
+- **💻 System Monitoring**: Real-time system performance metrics
+
+## 🛠️ Technology Stack
+
+- **Frontend**: Gradio web interface
+- **Backend**: Python with integrated AI capabilities
+- **AI Integration**: Google Gemini API (configurable)
+- **Data Storage**: JSON-based local storage
+- **File Processing**: Support for multiple document formats
+
+## 🏃‍♂️ Quick Start
+
+### Local Development
+
+1. **Clone the repository**
+   ```bash
+   git clone <your-repo-url>
+   cd ai-assistant-gradio
+   ```
+
+2. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Set up environment variables** (optional)
+   ```bash
+   # Create .env file
+   GEMINI_API_KEY=your_gemini_api_key_here
+   OPENAI_API_KEY=your_openai_api_key_here
+   ```
+
+4. **Run the application**
+   ```bash
+   python gradio_app.py
+   ```
+
+5. **Open your browser**
+   Navigate to `http://localhost:7860`
+
+### Hugging Face Spaces Deployment
+
+1. **Create a new Space** on [Hugging Face Spaces](https://huggingface.co/spaces)
+2. **Select Gradio** as the SDK
+3. **Upload these files**:
+   - `gradio_app.py` (main application)
+   - `requirements.txt` (dependencies)
+   - `README.md` (this file)
+4. **Add secrets** (if using AI APIs):
+   - `GEMINI_API_KEY`: Your Google Gemini API key
+   - `OPENAI_API_KEY`: Your OpenAI API key
+5. **Deploy** and your app will be live!
+
+## 📱 Usage Guide
+
+### Chat Interface
+- Type messages in the chat box to interact with the AI
+- Use example prompts to get started quickly
+- Chat history is automatically saved
+
+### Notes Management
+- Create notes with titles and content
+- View all notes in an organized display
+- Delete notes by exact title match
+- Notes persist between sessions
+
+### Reminders System
+- Set reminders with specific dates and times
+- Add descriptions for detailed reminders
+- Mark reminders as completed
+- View active and completed reminders
+
+### Document Processing
+- Upload PDF, TXT, or Markdown files
+- Get automatic analysis and content preview
+- Files are saved for future reference
+- Content can be queried through chat
+
+### System Monitoring
+- View real-time system performance
+- Monitor CPU, memory, and disk usage
+- Track application statistics
+- Auto-refresh every 30 seconds
+
+## 🔧 Configuration
+
+### Environment Variables
+
+- `GEMINI_API_KEY`: Google Gemini API key for AI responses
+- `OPENAI_API_KEY`: OpenAI API key (alternative AI provider)
+- `DEBUG`: Set to `true` for debug mode
+- `PORT`: Custom port (default: 7860)
+
+### Customization
+
+The application is designed to be easily customizable:
+
+- **AI Provider**: Modify the `_generate_mock_response` method to integrate with different AI services
+- **Storage**: Replace JSON storage with database integration
+- **UI Theme**: Customize the Gradio theme and CSS
+- **Features**: Add or remove tabs and functionality as needed
+
+## 📊 Data Storage
+
+Data is stored locally in JSON files:
+- `data/notes.json`: User notes
+- `data/reminders.json`: User reminders  
+- `data/chat_history.json`: Chat conversation history
+- `data/documents/`: Uploaded documents
+
+## 🔒 Security Notes
+
+- Data is stored locally and not shared externally
+- API keys should be kept secure and not committed to version control
+- File uploads are processed locally and stored in the data directory
+- Consider implementing user authentication for production use
+
+## 🚀 Deployment Options
+
+### Hugging Face Spaces (Recommended)
+- Free hosting for public applications
+- Automatic deployment from Git repository
+- Built-in secrets management
+- Easy sharing and collaboration
+
+### Other Platforms
+- **Streamlit Cloud**: Alternative free hosting
+- **Railway**: Easy deployment with custom domains
+- **Heroku**: Traditional cloud platform
+- **DigitalOcean**: VPS deployment
+- **Local Server**: Self-hosted solution
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit issues, feature requests, or pull requests.
+
+### Development Setup
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Test thoroughly
+5. Submit a pull request
+
+## 📄 License
+
+This project is open source and available under the MIT License.
+
+## 🆘 Support
+
+If you encounter any issues or have questions:
+
+1. Check the [Issues](https://github.com/your-repo/issues) page
+2. Create a new issue with detailed information
+3. Join the discussion in the community
+
+## 🎯 Roadmap
+
+Future enhancements planned:
+- [ ] User authentication and multi-user support
+- [ ] Database integration (PostgreSQL, MongoDB)
+- [ ] Advanced AI integrations
+- [ ] Mobile app companion
+- [ ] API endpoints for external integration
+- [ ] Advanced document analysis
+- [ ] Email and calendar integration
+- [ ] Voice commands and speech synthesis
+- [ ] Plugin system for extensibility
+
+---
+
+**Built with ❤️ using Gradio and Python**
+
+*Perfect for deployment on Hugging Face Spaces!*

app.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""
+AI Assistant - Hugging Face Spaces Entry Point
+This is the main entry point for Hugging Face Spaces deployment
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add the current directory to Python path
+sys.path.append(str(Path(__file__).parent))
+
+# Import and run the Gradio application
+from gradio_app import create_gradio_interface
+
+if __name__ == "__main__":
+    # Create the Gradio interface
+    app = create_gradio_interface()
+    
+    # Launch with Hugging Face Spaces compatible settings
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", 7860)),
+        share=False,
+        debug=False,
+        show_error=True,
+        quiet=False
+    )

gradio_app.py

@@ -0,0 +1,636 @@
+#!/usr/bin/env python3
+"""
+AI Assistant - Gradio Web Application
+Combines frontend and backend functionality in a single Gradio interface
+Suitable for deployment on Hugging Face Spaces
+"""
+
+import gradio as gr
+import json
+import os
+import tempfile
+import shutil
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional, Tuple
+import logging
+from pathlib import Path
+
+# Import your existing backend components
+try:
+    from voice_assistant import AIAssistant
+    from config_manager import ConfigManager
+    from error_handler import ErrorHandler
+except ImportError:
+    # Fallback imports if modules are not available
+    print("Warning: Some backend modules not found. Using mock implementations.")
+    AIAssistant = None
+    ConfigManager = None
+    ErrorHandler = None
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class GradioAIAssistant:
+    """Gradio-compatible AI Assistant wrapper"""
+    
+    def __init__(self):
+        self.data_dir = Path("data")
+        self.data_dir.mkdir(exist_ok=True)
+        
+        # Initialize backend components
+        self.config_manager = ConfigManager() if ConfigManager else None
+        self.error_handler = ErrorHandler() if ErrorHandler else None
+        self.ai_assistant = AIAssistant() if AIAssistant else None
+        
+        # Initialize data storage
+        self.notes_file = self.data_dir / "notes.json"
+        self.reminders_file = self.data_dir / "reminders.json"
+        self.chat_history_file = self.data_dir / "chat_history.json"
+        self.documents_dir = self.data_dir / "documents"
+        self.documents_dir.mkdir(exist_ok=True)
+        
+        # Load existing data
+        self.notes = self._load_json(self.notes_file, [])
+        self.reminders = self._load_json(self.reminders_file, [])
+        self.chat_history = self._load_json(self.chat_history_file, [])
+        
+        logger.info("Gradio AI Assistant initialized successfully")
+    
+    def _load_json(self, file_path: Path, default: Any) -> Any:
+        """Load JSON data from file with fallback to default"""
+        try:
+            if file_path.exists():
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+        except Exception as e:
+            logger.error(f"Error loading {file_path}: {e}")
+        return default
+    
+    def _save_json(self, file_path: Path, data: Any) -> bool:
+        """Save data to JSON file"""
+        try:
+            with open(file_path, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False, default=str)
+            return True
+        except Exception as e:
+            logger.error(f"Error saving {file_path}: {e}")
+            return False
+    
+    def chat_with_ai(self, message: str, history: List[List[str]]) -> Tuple[str, List[List[str]]]:
+        """Handle chat interaction with AI"""
+        if not message.strip():
+            return "", history
+        
+        try:
+            # Use AI assistant if available, otherwise provide mock response
+            if self.ai_assistant:
+                response = self.ai_assistant.process_query(message)
+                ai_response = response.get('response', 'Sorry, I could not process your request.')
+            else:
+                # Mock AI response for demo purposes
+                ai_response = self._generate_mock_response(message)
+            
+            # Update history
+            history.append([message, ai_response])
+            
+            # Save chat history
+            self.chat_history = history
+            self._save_json(self.chat_history_file, history)
+            
+            return "", history
+            
+        except Exception as e:
+            logger.error(f"Error in chat: {e}")
+            error_response = f"Sorry, I encountered an error: {str(e)}"
+            history.append([message, error_response])
+            return "", history
+    
+    def _generate_mock_response(self, message: str) -> str:
+        """Generate mock AI responses for demo purposes"""
+        message_lower = message.lower()
+        
+        if any(word in message_lower for word in ['hello', 'hi', 'hey']):
+            return "Hello! I'm your AI Assistant. How can I help you today?"
+        
+        elif any(word in message_lower for word in ['note', 'notes']):
+            return f"I can help you manage notes! You currently have {len(self.notes)} notes. Would you like to create a new note or view existing ones?"
+        
+        elif any(word in message_lower for word in ['reminder', 'remind']):
+            return f"I can help you set reminders! You have {len(self.reminders)} active reminders. What would you like to be reminded about?"
+        
+        elif any(word in message_lower for word in ['weather']):
+            return "I'd love to help with weather information! In a full deployment, I would connect to weather APIs to provide current conditions and forecasts."
+        
+        elif any(word in message_lower for word in ['code', 'programming', 'python']):
+            return "I can help with coding! Here's a simple Python example:\n\n```python\ndef greet(name):\n    return f'Hello, {name}!'\n\nprint(greet('World'))\n```\n\nWhat programming topic would you like help with?"
+        
+        elif any(word in message_lower for word in ['help', 'what can you do']):
+            return """I'm your AI Assistant! Here's what I can help you with:
+
+🗨️ **Chat**: Have conversations and ask questions
+📝 **Notes**: Create, edit, and manage your notes
+⏰ **Reminders**: Set and manage time-based reminders
+📄 **Documents**: Upload and analyze documents
+📊 **System Info**: Monitor system performance
+💻 **Code Help**: Programming assistance and examples
+
+Try asking me about any of these topics!"""
+        
+        else:
+            return f"Thank you for your message: '{message}'. In a full deployment with AI integration, I would provide intelligent responses based on advanced language models. For now, I'm running in demo mode!"
+    
+    def create_note(self, title: str, content: str) -> str:
+        """Create a new note"""
+        if not title.strip():
+            return "❌ Please provide a title for the note."
+        
+        note = {
+            "id": len(self.notes) + 1,
+            "title": title.strip(),
+            "content": content.strip(),
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat()
+        }
+        
+        self.notes.append(note)
+        self._save_json(self.notes_file, self.notes)
+        
+        return f"✅ Note '{title}' created successfully!"
+    
+    def get_notes_display(self) -> str:
+        """Get formatted display of all notes"""
+        if not self.notes:
+            return "📝 No notes found. Create your first note above!"
+        
+        notes_text = f"📝 **Your Notes ({len(self.notes)} total)**\n\n"
+        
+        for note in sorted(self.notes, key=lambda x: x['created_at'], reverse=True):
+            created = datetime.fromisoformat(note['created_at']).strftime("%Y-%m-%d %H:%M")
+            notes_text += f"**{note['title']}**\n"
+            notes_text += f"*Created: {created}*\n"
+            notes_text += f"{note['content'][:200]}{'...' if len(note['content']) > 200 else ''}\n"
+            notes_text += "---\n"
+        
+        return notes_text
+    
+    def delete_note(self, note_title: str) -> Tuple[str, str]:
+        """Delete a note by title"""
+        if not note_title.strip():
+            return "❌ Please provide a note title to delete.", self.get_notes_display()
+        
+        original_count = len(self.notes)
+        self.notes = [note for note in self.notes if note['title'].lower() != note_title.lower().strip()]
+        
+        if len(self.notes) < original_count:
+            self._save_json(self.notes_file, self.notes)
+            return f"✅ Note '{note_title}' deleted successfully!", self.get_notes_display()
+        else:
+            return f"❌ Note '{note_title}' not found.", self.get_notes_display()
+    
+    def create_reminder(self, title: str, description: str, reminder_time: str) -> str:
+        """Create a new reminder"""
+        if not title.strip():
+            return "❌ Please provide a title for the reminder."
+        
+        try:
+            # Parse the reminder time (expecting format like "2024-12-25 14:30")
+            if reminder_time:
+                reminder_datetime = datetime.fromisoformat(reminder_time.replace('T', ' '))
+            else:
+                reminder_datetime = datetime.now() + timedelta(hours=1)  # Default to 1 hour from now
+            
+            reminder = {
+                "id": len(self.reminders) + 1,
+                "title": title.strip(),
+                "description": description.strip(),
+                "reminder_time": reminder_datetime.isoformat(),
+                "created_at": datetime.now().isoformat(),
+                "completed": False
+            }
+            
+            self.reminders.append(reminder)
+            self._save_json(self.reminders_file, self.reminders)
+            
+            return f"✅ Reminder '{title}' set for {reminder_datetime.strftime('%Y-%m-%d %H:%M')}!"
+            
+        except ValueError:
+            return "❌ Invalid time format. Please use YYYY-MM-DD HH:MM format."
+    
+    def get_reminders_display(self) -> str:
+        """Get formatted display of all reminders"""
+        if not self.reminders:
+            return "⏰ No reminders found. Create your first reminder above!"
+        
+        active_reminders = [r for r in self.reminders if not r.get('completed', False)]
+        completed_reminders = [r for r in self.reminders if r.get('completed', False)]
+        
+        reminders_text = f"⏰ **Your Reminders**\n\n"
+        
+        if active_reminders:
+            reminders_text += f"**Active Reminders ({len(active_reminders)})**\n\n"
+            for reminder in sorted(active_reminders, key=lambda x: x['reminder_time']):
+                reminder_time = datetime.fromisoformat(reminder['reminder_time']).strftime("%Y-%m-%d %H:%M")
+                reminders_text += f"**{reminder['title']}**\n"
+                reminders_text += f"*Time: {reminder_time}*\n"
+                if reminder['description']:
+                    reminders_text += f"{reminder['description']}\n"
+                reminders_text += "---\n"
+        
+        if completed_reminders:
+            reminders_text += f"\n**Completed Reminders ({len(completed_reminders)})**\n\n"
+            for reminder in completed_reminders[-5:]:  # Show last 5 completed
+                reminder_time = datetime.fromisoformat(reminder['reminder_time']).strftime("%Y-%m-%d %H:%M")
+                reminders_text += f"~~{reminder['title']}~~ ✅\n"
+        
+        return reminders_text
+    
+    def complete_reminder(self, reminder_title: str) -> Tuple[str, str]:
+        """Mark a reminder as completed"""
+        if not reminder_title.strip():
+            return "❌ Please provide a reminder title to complete.", self.get_reminders_display()
+        
+        for reminder in self.reminders:
+            if reminder['title'].lower() == reminder_title.lower().strip():
+                reminder['completed'] = True
+                self._save_json(self.reminders_file, self.reminders)
+                return f"✅ Reminder '{reminder_title}' marked as completed!", self.get_reminders_display()
+        
+        return f"❌ Reminder '{reminder_title}' not found.", self.get_reminders_display()
+    
+    def process_document(self, file) -> str:
+        """Process uploaded document"""
+        if file is None:
+            return "❌ Please upload a file."
+        
+        try:
+            # Get file info
+            file_path = Path(file.name)
+            file_size = os.path.getsize(file.name)
+            file_extension = file_path.suffix.lower()
+            
+            # Copy file to documents directory
+            dest_path = self.documents_dir / f"{datetime.now().strftime('%Y%m%d_%H%M%S')}_{file_path.name}"
+            shutil.copy2(file.name, dest_path)
+            
+            # Read file content based on type
+            content_preview = ""
+            if file_extension in ['.txt', '.md']:
+                with open(file.name, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    content_preview = content[:500] + "..." if len(content) > 500 else content
+            elif file_extension == '.pdf':
+                content_preview = "PDF file uploaded successfully. In a full deployment, I would extract and analyze the PDF content."
+            else:
+                content_preview = f"File type {file_extension} uploaded successfully."
+            
+            # Generate analysis (mock for demo)
+            analysis = f"""📄 **Document Analysis**
+
+**File:** {file_path.name}
+**Size:** {file_size:,} bytes
+**Type:** {file_extension}
+**Uploaded:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
+
+**Content Preview:**
+{content_preview}
+
+**AI Analysis:**
+This document appears to contain {len(content_preview.split())} words. In a full deployment with AI integration, I would provide:
+- Detailed content summary
+- Key topics and themes
+- Extracted insights
+- Question-answering capabilities
+- Content categorization
+
+The document has been saved and can be referenced in future conversations!"""
+            
+            return analysis
+            
+        except Exception as e:
+            logger.error(f"Error processing document: {e}")
+            return f"❌ Error processing document: {str(e)}"
+    
+    def get_system_info(self) -> str:
+        """Get system information"""
+        try:
+            import psutil
+            import platform
+            
+            # Get system info
+            cpu_percent = psutil.cpu_percent(interval=1)
+            memory = psutil.virtual_memory()
+            disk = psutil.disk_usage('/')
+            
+            system_info = f"""💻 **System Information**
+
+**Platform:** {platform.system()} {platform.release()}
+**Python:** {platform.python_version()}
+**Architecture:** {platform.machine()}
+
+**Performance Metrics:**
+- **CPU Usage:** {cpu_percent}%
+- **Memory Usage:** {memory.percent}% ({memory.used // (1024**3):.1f}GB / {memory.total // (1024**3):.1f}GB)
+- **Disk Usage:** {disk.percent}% ({disk.used // (1024**3):.1f}GB / {disk.total // (1024**3):.1f}GB)
+
+**Application Status:**
+- **Notes:** {len(self.notes)} stored
+- **Reminders:** {len([r for r in self.reminders if not r.get('completed', False)])} active
+- **Chat History:** {len(self.chat_history)} messages
+- **Documents:** {len(list(self.documents_dir.glob('*')))} files
+
+*Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*"""
+            
+            return system_info
+            
+        except ImportError:
+            return """💻 **System Information**
+
+*System monitoring requires psutil package*
+
+**Application Status:**
+- **Notes:** {len(self.notes)} stored
+- **Reminders:** {len([r for r in self.reminders if not r.get('completed', False)])} active
+- **Chat History:** {len(self.chat_history)} messages
+
+*Last updated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*"""
+        except Exception as e:
+            return f"❌ Error getting system info: {str(e)}"
+
+def create_gradio_interface():
+    """Create and configure the Gradio interface"""
+    
+    # Initialize the AI Assistant
+    assistant = GradioAIAssistant()
+    
+    # Custom CSS for better styling
+    custom_css = """
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .tab-nav {
+        background: linear-gradient(90deg, #0ea5e9, #3b82f6) !important;
+    }
+    .tab-nav button {
+        color: white !important;
+    }
+    .tab-nav button.selected {
+        background: rgba(255,255,255,0.2) !important;
+    }
+    """
+    
+    # Create the main interface
+    with gr.Blocks(
+        title="AI Assistant - Your Intelligent Companion",
+        theme=gr.themes.Soft(),
+        css=custom_css
+    ) as app:
+        
+        gr.Markdown("""
+        # 🤖 AI Assistant - Your Intelligent Companion
+        
+        Welcome to your personal AI Assistant! This application combines chat, notes, reminders, document processing, and system monitoring in one place.
+        
+        **Features:**
+        - 💬 **Smart Chat**: Intelligent conversations and assistance
+        - 📝 **Notes**: Create and manage your notes
+        - ⏰ **Reminders**: Set time-based notifications
+        - 📄 **Documents**: Upload and analyze files
+        - 💻 **System**: Monitor performance metrics
+        """)
+        
+        with gr.Tabs():
+            
+            # Chat Tab
+            with gr.Tab("💬 Chat", id="chat"):
+                gr.Markdown("### Chat with your AI Assistant")
+                
+                chatbot = gr.Chatbot(
+                    value=assistant.chat_history,
+                    height=400,
+                    show_label=False,
+                    container=True,
+                    bubble_full_width=False
+                )
+                
+                with gr.Row():
+                    msg_input = gr.Textbox(
+                        placeholder="Type your message here...",
+                        show_label=False,
+                        scale=4,
+                        container=False
+                    )
+                    send_btn = gr.Button("Send", variant="primary", scale=1)
+                
+                gr.Examples(
+                    examples=[
+                        "Hello! How can you help me?",
+                        "What can you do?",
+                        "Help me with Python code",
+                        "Tell me about my notes",
+                        "What reminders do I have?",
+                        "Explain machine learning",
+                    ],
+                    inputs=msg_input
+                )
+                
+                # Chat functionality
+                msg_input.submit(
+                    assistant.chat_with_ai,
+                    inputs=[msg_input, chatbot],
+                    outputs=[msg_input, chatbot]
+                )
+                send_btn.click(
+                    assistant.chat_with_ai,
+                    inputs=[msg_input, chatbot],
+                    outputs=[msg_input, chatbot]
+                )
+            
+            # Notes Tab
+            with gr.Tab("📝 Notes", id="notes"):
+                gr.Markdown("### Manage Your Notes")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### Create New Note")
+                        note_title = gr.Textbox(label="Title", placeholder="Enter note title...")
+                        note_content = gr.Textbox(
+                            label="Content",
+                            placeholder="Enter note content...",
+                            lines=5
+                        )
+                        create_note_btn = gr.Button("Create Note", variant="primary")
+                        create_note_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        gr.Markdown("#### Delete Note")
+                        delete_title = gr.Textbox(label="Note Title to Delete", placeholder="Enter exact title...")
+                        delete_note_btn = gr.Button("Delete Note", variant="secondary")
+                        delete_note_status = gr.Textbox(label="Delete Status", interactive=False)
+                    
+                    with gr.Column(scale=2):
+                        gr.Markdown("#### Your Notes")
+                        notes_display = gr.Markdown(value=assistant.get_notes_display())
+                        refresh_notes_btn = gr.Button("Refresh Notes", variant="secondary")
+                
+                # Notes functionality
+                create_note_btn.click(
+                    assistant.create_note,
+                    inputs=[note_title, note_content],
+                    outputs=create_note_status
+                ).then(
+                    lambda: ("", ""),
+                    outputs=[note_title, note_content]
+                ).then(
+                    assistant.get_notes_display,
+                    outputs=notes_display
+                )
+                
+                delete_note_btn.click(
+                    assistant.delete_note,
+                    inputs=delete_title,
+                    outputs=[delete_note_status, notes_display]
+                ).then(
+                    lambda: "",
+                    outputs=delete_title
+                )
+                
+                refresh_notes_btn.click(
+                    assistant.get_notes_display,
+                    outputs=notes_display
+                )
+            
+            # Reminders Tab
+            with gr.Tab("⏰ Reminders", id="reminders"):
+                gr.Markdown("### Manage Your Reminders")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### Create New Reminder")
+                        reminder_title = gr.Textbox(label="Title", placeholder="Enter reminder title...")
+                        reminder_desc = gr.Textbox(
+                            label="Description",
+                            placeholder="Enter reminder description...",
+                            lines=3
+                        )
+                        reminder_time = gr.Textbox(
+                            label="Time (YYYY-MM-DD HH:MM)",
+                            placeholder="2024-12-25 14:30",
+                            info="Leave empty for 1 hour from now"
+                        )
+                        create_reminder_btn = gr.Button("Create Reminder", variant="primary")
+                        create_reminder_status = gr.Textbox(label="Status", interactive=False)
+                        
+                        gr.Markdown("#### Complete Reminder")
+                        complete_title = gr.Textbox(label="Reminder Title to Complete", placeholder="Enter exact title...")
+                        complete_reminder_btn = gr.Button("Complete Reminder", variant="secondary")
+                        complete_reminder_status = gr.Textbox(label="Complete Status", interactive=False)
+                    
+                    with gr.Column(scale=2):
+                        gr.Markdown("#### Your Reminders")
+                        reminders_display = gr.Markdown(value=assistant.get_reminders_display())
+                        refresh_reminders_btn = gr.Button("Refresh Reminders", variant="secondary")
+                
+                # Reminders functionality
+                create_reminder_btn.click(
+                    assistant.create_reminder,
+                    inputs=[reminder_title, reminder_desc, reminder_time],
+                    outputs=create_reminder_status
+                ).then(
+                    lambda: ("", "", ""),
+                    outputs=[reminder_title, reminder_desc, reminder_time]
+                ).then(
+                    assistant.get_reminders_display,
+                    outputs=reminders_display
+                )
+                
+                complete_reminder_btn.click(
+                    assistant.complete_reminder,
+                    inputs=complete_title,
+                    outputs=[complete_reminder_status, reminders_display]
+                ).then(
+                    lambda: "",
+                    outputs=complete_title
+                )
+                
+                refresh_reminders_btn.click(
+                    assistant.get_reminders_display,
+                    outputs=reminders_display
+                )
+            
+            # Documents Tab
+            with gr.Tab("📄 Documents", id="documents"):
+                gr.Markdown("### Document Processing")
+                
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("#### Upload Document")
+                        file_upload = gr.File(
+                            label="Choose File",
+                            file_types=[".txt", ".md", ".pdf"],
+                            type="filepath"
+                        )
+                        process_btn = gr.Button("Process Document", variant="primary")
+                    
+                    with gr.Column(scale=2):
+                        gr.Markdown("#### Document Analysis")
+                        doc_analysis = gr.Markdown(value="Upload a document to see analysis here...")
+                
+                # Document processing functionality
+                process_btn.click(
+                    assistant.process_document,
+                    inputs=file_upload,
+                    outputs=doc_analysis
+                )
+                
+                file_upload.change(
+                    assistant.process_document,
+                    inputs=file_upload,
+                    outputs=doc_analysis
+                )
+            
+            # System Tab
+            with gr.Tab("💻 System", id="system"):
+                gr.Markdown("### System Information")
+                
+                system_display = gr.Markdown(value=assistant.get_system_info())
+                refresh_system_btn = gr.Button("Refresh System Info", variant="primary")
+                
+                refresh_system_btn.click(
+                    assistant.get_system_info,
+                    outputs=system_display
+                )
+                
+                # Auto-refresh every 30 seconds
+                app.load(
+                    assistant.get_system_info,
+                    outputs=system_display,
+                    every=30
+                )
+        
+        gr.Markdown("""
+        ---
+        
+        **About this AI Assistant:**
+        - Built with Gradio for easy deployment on Hugging Face Spaces
+        - Combines chat, notes, reminders, document processing, and system monitoring
+        - Data is stored locally and persists between sessions
+        - Designed for both personal use and demonstration purposes
+        
+        **Deployment Ready:** This application can be easily deployed to Hugging Face Spaces, Streamlit Cloud, or any Python hosting platform.
+        """)
+    
+    return app
+
+if __name__ == "__main__":
+    # Create and launch the Gradio app
+    app = create_gradio_interface()
+    
+    # Launch with appropriate settings
+    app.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7860,       # Standard Gradio port
+        share=False,            # Set to True for public sharing
+        debug=True,             # Enable debug mode
+        show_error=True,        # Show detailed errors
+        quiet=False             # Show startup logs
+    )

requirements.txt

@@ -0,0 +1,39 @@
+# Core dependencies for Gradio AI Assistant
+gradio>=4.0.0
+python-dotenv>=1.0.0
+requests>=2.31.0
+
+# AI and ML libraries
+google-generativeai>=0.3.0
+openai>=1.0.0
+
+# Data processing
+pandas>=2.0.0
+numpy>=1.24.0
+
+# File processing
+PyPDF2>=3.0.0
+python-docx>=0.8.11
+markdown>=3.5.0
+
+# System monitoring
+psutil>=5.9.0
+
+# Audio processing (optional)
+SpeechRecognition>=3.10.0
+pyttsx3>=2.90
+
+# Web scraping (optional)
+beautifulsoup4>=4.12.0
+requests-html>=0.10.0
+
+# Database (optional)
+sqlite3
+
+# Utilities
+python-dateutil>=2.8.0
+pytz>=2023.3
+
+# Development tools (optional)
+black>=23.0.0
+flake8>=6.0.0