Update app.py

chat. journal AI

app.py

@@ -2,221 +2,477 @@ import gradio as gr
 import requests
 import os
 import json
-from typing import List, Dict
-from datetime import datetime
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime, timedelta
+from collections import Counter, defaultdict
+import re
+from pathlib import Path
 
 # Groq API Configuration
 API_URL = "https://api.groq.com/openai/v1/chat/completions"
 API_KEY = os.getenv("GROQ_API_KEY")
 
-# In-memory chat history storage
-chat_history: List[Dict[str, str]] = []
+# Storage Configuration
+STORAGE_DIR = Path("chat_storage")
+STORAGE_DIR.mkdir(exist_ok=True)
+HISTORY_FILE = STORAGE_DIR / "chat_history.json"
+ANALYTICS_FILE = STORAGE_DIR / "analytics.json"
+
+class ChatStorage:
+    """Handles persistent JSON storage for chat history"""
+    
+    def __init__(self):
+        self.history_file = HISTORY_FILE
+        self.analytics_file = ANALYTICS_FILE
+        self.chat_history = self.load_history()
+        self.analytics = self.load_analytics()
+    
+    def load_history(self) -> List[Dict]:
+        try:
+            if self.history_file.exists():
+                with open(self.history_file, ' Retired: 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    print(f"📚 Loaded {len(data)} messages from storage")
+                    return data
+        except Exception as e:
+            print(f"❌ Error loading history: {e}")
+        return []
+    
+    def save_history(self):
+        try:
+            with open(self.history_file, 'w', encoding='utf-8') as f:
+                json.dump(self.chat_history, f, indent=2, ensure_ascii=False)
+            print(f"💾 Saved {len(self.chat_history)} messages to storage")
+        except Exception as e:
+            print(f"❌ Error saving history: {e}")
+    
+    def load_analytics(self) -> Dict:
+        try:
+            if self.analytics_file.exists():
+                with open(self.analytics_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+        except Exception as e:
+            print(f"❌ Error loading analytics: {e}")
+        return {}
+    
+    def save_analytics(self):
+        try:
+            with open(self.analytics_file, 'w', encoding='utf-8') as f:
+                json.dump(self.analytics, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"❌ Error saving analytics: {e}")
+    
+    def add_message(self, role: str, content: str, topic: str = "general"):
+        message = {
+            "role": role,
+            "content": content,
+            "topic": topic,
+            "timestamp": datetime.now().isoformat(),
+            "word_count": len(content.split()),
+            "char_count": len(content)
+        }
+        self.chat_history.append(message)
+        self.save_history()
+        self.update_analytics(message)
+    
+    def update_analytics(self, message: Dict):
+        today = datetime.now().strftime("%Y-%m-%d")
+        if "daily_stats" not in self.analytics:
+            self.analytics["daily_stats"] = {}
+        if today not in self.analytics["daily_stats"]:
+            self.analytics["daily_stats"][today] = {
+                "messages": 0,
+                "words": 0,
+                "chars": 0,
+                "topics": set()
+            }
+        stats = self.analytics["daily_stats"][today]
+        stats["messages"] += 1
+        stats["words"] += message["word_count"]
+        stats["chars"] += message["char_count"]
+        stats["topics"].add(message["topic"])
+        stats["topics"] = list(stats["topics"])
+        self.save_analytics()
+    
+    def clear_history(self):
+        self.chat_history.clear()
+        self.analytics.clear()
+        self.save_history()
+        self.save_analytics()
+    
+    def create_backup(self):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_dir = STORAGE_DIR / "backups"
+        backup_dir.mkdir(exist_ok=True)
+        for file in [HISTORY_FILE, ANALYTICS_FILE]:
+            backup_path = backup_dir / f"{file.name}.{timestamp}.bak"
+            with open(file, 'r') as src, open(backup_path, 'w') as dst:
+                dst.write(src.read())
+        return f"✅ Backup created at {backup_dir}"
+
+class SmartAnalyzer:
+    """Advanced analytics for chat history"""
+    
+    def __init__(self, storage: ChatStorage):
+        self.storage = storage
+    
+    def get_conversation_patterns(self) -> Dict:
+        if not self.storage.chat_history:
+            return {"error": "No data available"}
+        topics = [msg.get("topic", "general") for msg in self.storage.chat_history]
+        topic_counts = Counter(topics)
+        timestamps = [datetime.fromisoformat(msg["timestamp"]) for msg in self.storage.chat_history]
+        hour_counts = Counter([ts.hour for ts in timestamps])
+        day_counts = Counter([ts.strftime("%A") for ts in timestamps])
+        all_words = []
+        for msg in self.storage.chat_history:
+            if msg["role"] == "user":
+                words = re.findall(r'\b\w+\b', msg["content"].lower())
+                all_words.extend(words)
+        common_words = Counter(all_words).most_common(10)
+        user_messages = [msg for msg in self.storage.chat_history if msg["role"] == "user"]
+        avg_words = sum(msg["word_count"] for msg in user_messages) / len(user_messages) if user_messages else 0
+        return {
+            "total_messages": len(self.storage.chat_history),
+            "user_messages": len(user_messages),
+            "topics": dict(topic_counts),
+            "peak_hours": dict(sorted(hour_counts.items())),
+            "peak_days": dict(day_counts),
+            "common_words": common_words,
+            "avg_words_per_message": round(avg_words, 1),
+            "date_range": {
+                "start": min(timestamps).strftime("%Y-%m-%d") if timestamps else None,
+                "end": max(timestamps).strftime("%Y-%m-%d") if timestamps else None
+            }
+        }
+    
+    def get_mood_trends(self) -> Dict:
+        if not self.storage.chat_history:
+            return {"error": "No data available"}
+        user_messages = [msg for msg in self.storage.chat_history if msg["role"] == "user"]
+        positive_words = {'good', 'great', 'happy', 'excited', 'amazing', 'wonderful', 'excellent', 'love', 'like', 'enjoy'}
+        negative_words = {'bad', 'sad', 'angry', 'frustrated', 'terrible', 'awful', 'hate', 'dislike', 'worried', 'stress'}
+        question_words = {'what', 'how', 'why', 'when', 'where', 'who', 'which'}
+        sentiments = []
+        for msg in user_messages:
+            words = set(re.findall(r'\b\w+\b', msg["content"].lower()))
+            pos_score = len(words & positive_words)
+            neg_score = len(words & negative_words)
+            question_score = len(words & question_words)
+            if pos_score > neg_score:
+                sentiment = "positive"
+            elif neg_score > pos_score:
+                sentiment = "negative"
+            elif question_score > 0:
+                sentiment = "curious"
+            else:
+                sentiment = "neutral"
+            sentiments.append({
+                "date": datetime.fromisoformat(msg["timestamp"]).strftime("%Y-%m-%d"),
+                "sentiment": sentiment,
+                "topic": msg.get("topic", "general")
+            })
+        daily_moods = defaultdict(list)
+        for item in sentiments:
+            daily_moods[item["date"]].append(item["sentiment"])
+        mood_summary = {}
+        for date, moods in daily_moods.items():
+            mood_counter = Counter(moods)
+            dominant_mood = mood_counter.most_common(1)[0][0]
+            mood_summary[date] = {
+                "dominant": dominant_mood,
+                "distribution": dict(mood_counter)
+            }
+        return {
+            "daily_moods": mood_summary,
+            "overall_sentiment": Counter([s["sentiment"] for s in sentiments]),
+            "sentiment_by_topic": self._group_sentiment_by_topic(sentiments)
+        }
+    
+    def _group_sentiment_by_topic(self, sentiments: List[Dict]) -> Dict:
+        topic_sentiments = defaultdict(list)
+        for item in sentiments:
+            topic_sentiments[item["topic"]].append(item["sentiment"])
+        result = {}
+        for topic, sent_list in topic_sentiments.items():
+            result[topic] = dict(Counter(sent_list))
+        return result
+    
+    def get_productivity_insights(self) -> Dict:
+        if not self.storage.chat_history:
+            return {"error": "No data available"}
+        daily_activity = defaultdict(int)
+        for msg in self.storage.chat_history:
+            if msg["role"] == "user":
+                date = datetime.fromisoformat(msg["timestamp"]).strftime("%Y-%m-%d")
+                daily_activity[date] += 1
+        weekly_activity = defaultdict(int)
+        for msg in self.storage.chat_history:
+            if msg["role"] == "user":
+                day = datetime.fromisoformat(msg["timestamp"]).strftime("%A")
+                weekly_activity[day] += 1
+        topic_timeline = []
+        for msg in self.storage.chat_history:
+            if msg["role"] == "user":
+                topic_timeline.append({
+                    "date": datetime.fromisoformat(msg["timestamp"]).strftime("%Y-%m-%d"),
+                    "topic": msg.get("topic", "general")
+                })
+        recent_cutoff = datetime.now() - timedelta(days=7)
+        recent_messages = [
+            msg for msg in self.storage.chat_history 
+            if datetime.fromisoformat(msg["timestamp"]) > recent_cutoff and msg["role"] == "user"
+        ]
+        return {
+            "daily_activity": dict(sorted(daily_activity.items())),
+            "weekly_patterns": dict(weekly_activity),
+            "most_active_day": max(daily_activity.items(), key=lambda x: x[1]) if daily_activity else None,
+            "recent_activity": len(recent_messages),
+            "topic_evolution": topic_timeline[-10:],
+            "consistency_score": self._calculate_consistency(daily_activity)
+        }
+    
+    def _calculate_consistency(self, daily_activity: Dict) -> float:
+        if len(daily_activity) < 2:
+            return 0.0
+        values = list(daily_activity.values())
+        avg = sum(values) / len(values)
+        variance = sum((x - avg) ** 2 for x in values) / len(values)
+        consistency = max(0, 100 - (variance / avg * 10)) if avg > 0 else 0
+        return round(consistency, 1)
+
+# Initialize storage and analyzer
+storage = ChatStorage()
+analyzer = SmartAnalyzer(storage)
 
 def count_tokens_rough(text: str) -> int:
-    """Rough token estimation (1 token ≈ 4 chars)"""
     return len(text) // 4
 
 def groq_with_memory(message: str, topic: str = "general") -> tuple:
-    """Groq API call with smart context management"""
-    
     if not API_KEY:
-        return "❌ No API Key found", ""
-    
+        return "❌ No API Key found. Please set GROQ_API_KEY environment variable.", ""
     if not message.strip():
         return "❌ Empty message", ""
-    
     try:
         headers = {
             "Authorization": f"Bearer {API_KEY}",
             "Content-Type": "application/json"
         }
-        
-        # Add current message to history
-        chat_history.append({
-            "role": "user",
-            "content": message.strip(),
-            "topic": topic,
-            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M")
-        })
-        
-        # Smart context management - keep within ~6000 tokens (24k chars)
+        storage.add_message("user", message.strip(), topic)
         messages = []
         total_chars = 0
-        max_chars = 24000  # Safe limit for gemma2-9b-it
-        
-        # Add messages from most recent, working backwards
-        for msg in reversed(chat_history):
+        max_chars = 24000
+        for msg in reversed(storage.chat_history):
             msg_content = f"{msg['content']}"
             msg_chars = len(msg_content)
-            
             if total_chars + msg_chars < max_chars:
                 messages.insert(0, {"role": msg["role"], "content": msg["content"]})
                 total_chars += msg_chars
             else:
                 break
-        
-        # Ensure we have at least the current message
         if not messages:
             messages = [{"role": "user", "content": message.strip()}]
-        
         payload = {
             "model": "gemma2-9b-it",
             "messages": messages,
-            "max_tokens": 2000,  # Conservative for safety
+            "max_tokens": 2000,
             "temperature": 0.7
         }
-        
         response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
-        
         if response.status_code == 200:
             result = response.json()
             if "choices" in result and result["choices"]:
                 response_content = result["choices"][0]["message"]["content"]
-                chat_history.append({
-                    "role": "assistant",
-                    "content": response_content,
-                    "topic": topic,
-                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M")
-                })
-                return response_content, ""  # Clear input after send
+                storage.add_message("assistant", response_content, topic)
+                return response_content, ""
             return f"❌ No response: {result}", ""
         return f"❌ HTTP {response.status_code}: {response.text}", ""
-            
     except Exception as e:
         return f"❌ Error: {str(e)}", ""
 
 def get_chat_summary(topic_filter: str = None) -> str:
-    """Generate conversation summary"""
-    if not chat_history:
+    if not storage.chat_history:
         return "❌ No chat history to summarize"
-    
-    filtered = [msg for msg in chat_history if not topic_filter or msg.get("topic") == topic_filter]
-    
+    filtered = [msg for msg in storage.chat_history if not topic_filter or msg.get("topic") == topic_filter]
     if not filtered:
         return f"❌ No messages found for topic: {topic_filter}"
-    
-    # Group by topic
     topics = {}
     for msg in filtered:
         topic = msg.get("topic", "general")
         if topic not in topics:
             topics[topic] = []
         topics[topic].append(msg)
-    
     summary = "📋 **Chat Summary**\n\n"
     for topic, messages in topics.items():
         user_msgs = [m for m in messages if m["role"] == "user"]
         ai_msgs = [m for m in messages if m["role"] == "assistant"]
-        
         summary += f"**🏷️ Topic: {topic}**\n"
         summary += f"- Messages: {len(user_msgs)} user, {len(ai_msgs)} AI\n"
-        summary += f"- Time span: {messages[0]['timestamp']} - {messages[-1]['timestamp']}\n"
-        
+        summary += f"- Time span: {messages[0]['timestamp'][:10]} - {messages[-1]['timestamp'][:10]}\n"
+        summary += f"- Total words: {sum(m['word_count'] for m in user_msgs):,}\n"
         if user_msgs:
             summary += f"- Key topics discussed: {', '.join(msg['content'][:50] + '...' for msg in user_msgs[:3])}\n"
         summary += "\n"
-    
     return summary
 
 def get_full_history(topic_filter: str = None) -> str:
-    """Get full chat history with optional topic filter"""
-    if not chat_history:
+    if not storage.chat_history:
         return "❌ No chat history available"
-    
-    filtered = [msg for msg in chat_history if not topic_filter or msg.get("topic") == topic_filter]
-    
+    filtered = [msg for msg in storage.chat_history if not topic_filter or msg.get("topic") == topic_filter]
     if not filtered:
         return f"❌ No messages found for topic: {topic_filter}"
-    
     history_text = f"📚 **Chat History** ({len(filtered)} messages)\n\n"
-    
     current_topic = None
     for msg in filtered:
-        # Add topic header when topic changes
         if msg.get("topic") != current_topic:
             current_topic = msg.get("topic")
             history_text += f"\n**🏷️ Topic: {current_topic}**\n"
             history_text += "---\n"
-        
         role_icon = "👤" if msg["role"] == "user" else "🤖"
-        history_text += f"{role_icon} **{msg['timestamp']}**\n"
+        timestamp = msg['timestamp'][:19].replace('T', ' ')
+        history_text += f"{role_icon} **{timestamp}** ({msg['word_count']} words)\n"
         history_text += f"{msg['content']}\n\n"
-    
     return history_text
 
+def get_analytics_report() -> str:
+    patterns = analyzer.get_conversation_patterns()
+    moods = analyzer.get_mood_trends()
+    productivity = analyzer.get_productivity_insights()
+    if "error" in patterns:
+        return "❌ No data available for analytics"
+    report = "📊 **Smart Analytics Report**\n\n"
+    report += "## 📈 Overview\n"
+    report += f"- **Total Messages**: {patterns['total_messages']:,}\n"
+    report += f"- **Your Messages**: {patterns['user_messages']:,}\n"
+    report += f"- **Average Words per Message**: {patterns['avg_words_per_message']}\n"
+    report += f"- **Date Range**: {patterns['date_range']['start']} to {patterns['date_range']['end']}\n\n"
+    report += "## 🏷️ Topic Distribution\n"
+    for topic, count in sorted(patterns['topics'].items(), key=lambda x: x[1], reverse=True):
+        percentage = (count / patterns['total_messages']) * 100
+        report += f"- **{topic}**: {count} messages ({percentage:.1f}%)\n"
+    report += "\n"
+    report += "## ⏰ Activity Patterns\n"
+    if productivity['most_active_day']:
+        report += f"- **Most Active Day**: {productivity['most_active_day'][0]} ({productivity['most_active_day'][1]} messages)\n"
+    peak_hours = sorted(patterns['peak_hours'].items(), key=lambda x: x[1], reverse=True)[:3]
+    report += f"- **Peak Hours**: {', '.join(f'{h}:00 ({c} msgs)' for h, c in peak_hours)}\n"
+    report += "- **Weekly Activity**:\n"
+    for day, count in patterns['peak_days'].items():
+        report += f"  - {day}: {count} messages\n"
+    report += f"- **Consistency Score**: {productivity['consistency_score']}/100\n"
+    report += f"- **Recent Activity (7 days)**: {productivity['recent_activity']} messages\n\n"
+    if "error" not in moods:
+        report += "## 😊 Mood & Sentiment Analysis\n"
+        overall_sentiment = moods['overall_sentiment']
+        total_analyzed = sum(overall_sentiment.values())
+        for sentiment, count in overall_sentiment.most_common():
+            percentage = (count / total_analyzed) * 100
+            emoji = {"positive": "😊", "negative": "😔", "curious": "🤔", "neutral": "😐"}.get(sentiment, "❓")
+            report += f"- **{sentiment.title()}** {emoji}: {count} messages ({percentage:.1f}%)\n"
+        report += "\n**Sentiment by Topic**:\n"
+        for topic, sentiments in moods['sentiment_by_topic'].items():
+            report += f"- **{topic}**: "
+            sentiment_strs = [f"{sent}({count})" for sent, count in sentiments.items()]
+            report += ", ".join(sentiment_strs) + "\n"
+        report += "\n"
+    report += "## 🔤 Most Common Words\n"
+    for word, count in patterns['common_words']:
+        report += f"- **{word}**: {count} times\n"
+    report += "\n"
+    if productivity['topic_evolution']:
+        report += "## 📈 Recent Topic Evolution\n"
+        for entry in productivity['topic_evolution'][-5:]:
+            report += f"- {entry['date']}: {entry['topic']}\n"
+    return report
+
+def export_data() -> str:
+    export_data = {
+        "chat_history": storage.chat_history,
+        "analytics": storage.analytics,
+        "export_timestamp": datetime.now().isoformat(),
+        "total_messages": len(storage.chat_history)
+    }
+    return json.dumps(export_data, indent=2, ensure_ascii=False)
+
 def clear_all_history():
-    """Clear all chat history"""
-    global chat_history
-    chat_history.clear()
-    return "✅ All chat history cleared", "", ""
+    storage.clear_history()
+    return "✅ All chat history and analytics cleared", "", ""
 
 def get_topics_list() -> List[str]:
-    """Get list of unique topics"""
-    topics = list(set(msg.get("topic", "general") for msg in chat_history))
+    topics = list(set(msg.get("topic", "general") for msg in storage.chat_history))
     return ["All Topics"] + sorted(topics)
 
-# Custom CSS for better UI
+def show_current_context():
+    if not storage.chat_history:
+        return "❌ No conversation context yet"
+    messages = []
+    total_chars = 0
+    max_chars = 24000
+    for msg in reversed(storage.chat_history):
+        msg_chars = len(msg['content'])
+        if total_chars + msg_chars < max_chars:
+            messages.insert(0, msg)
+            total_chars += msg_chars
+        else:
+            break
+    context_text = f"🧠 **Current AI Context** ({len(messages)} messages, ~{total_chars:,} chars)\n\n"
+    for msg in messages:
+        role_icon = "👤" if msg["role"] == "user" else "🤖"
+        timestamp = msg['timestamp'][:19].replace('T', ' ')
+        context_text += f"{role_icon} **{timestamp}** [{msg.get('topic', 'general')}] ({msg['word_count']} words)\n"
+        context_text += f"{msg['content'][:150]}{'...' if len(msg['content']) > 150 else ''}\n\n"
+    context_text += f"\n💡 *AI remembers {len(messages)} messages (~{total_chars:,} characters)*"
+    context_text += f"\n🔢 *Context limit: {max_chars:,} characters*"
+    context_text += f"\n💾 *Total stored: {len(storage.chat_history)} messages*"
+    return context_text
+
+    # Custom CSS for better UI
 custom_css = """
 .gradio-container {
     max-width: 100% !important;
     padding: 0 !important;
     margin: 0 !important;
 }
-
 .main {
     max-width: 100% !important;
     padding: 10px !important;
 }
-
-/* Better font for readability */
 * {
     font-family: 'Inter', 'Segoe UI', system-ui, -apple-system, sans-serif !important;
 }
-
-/* AI Response text spacing */
 .response-area textarea {
     line-height: 1.7 !important;
     padding: 20px !important;
     font-size: 15px !important;
-    font-family: 'Inter', 'Segoe UI', system-ui, sans-serif !important;
 }
-
-/* History text spacing */
 .history-display textarea {
     line-height: 1.7 !important;
     padding: 20px !important;
     font-size: 15px !important;
-    font-family: 'Inter', 'Segoe UI', system-ui, sans-serif !important;
 }
-
-/* Input text styling */
 .input-area textarea {
-    font-family: 'Inter', 'Segoe UI', system-ui, sans-serif !important;
     font-size: 15px !important;
     line-height: 1.6 !important;
 }
-
-/* Better text readability everywhere */
-textarea, input {
-    line-height: 1.6 !important;
-    font-family: 'Inter', 'Segoe UI', system-ui, sans-serif !important;
+.analytics-display textarea {
+    line-height: 1.8 !important;
+    padding: 20px !important;
+    font-size: 14px !important;
 }
 """
 
 # Main Gradio Interface
 with gr.Blocks(
-    title="🤖 AI Journal Chat", 
+    title="🤖 AI Journal Chat with Analytics", 
     theme=gr.themes.Soft(),
     css=custom_css
 ) as demo:
     
     gr.Markdown("# 📝 AI Journal Chat Interface")
-    gr.Markdown("*Write, chat, and keep track of your thoughts with AI assistance*")
+    gr.Markdown("*Write, chat, and analyze your thoughts with AI assistance + persistent storage*")
     
     with gr.Tabs() as tabs:
-        # MAIN CHAT TAB
         with gr.Tab("💬 Chat"):
-            # AI Response Area (Top)
             ai_response = gr.Textbox(
                 label="🤖 AI Response",
                 lines=12,
@@ -226,8 +482,6 @@ with gr.Blocks(
                 show_copy_button=True,
                 elem_classes="response-area"
             )
-            
-            # Input Area (Bottom)
             with gr.Group():
                 with gr.Row():
                     user_input = gr.Textbox(
@@ -235,7 +489,8 @@ with gr.Blocks(
                         placeholder="Type your thoughts, questions, or journal entry here...",
                         lines=4,
                         max_lines=10,
-                        scale=3
+                        scale=3,
+                        elem_classes="input-area"
                     )
                     with gr.Column(scale=1):
                         topic_input = gr.Textbox(
@@ -244,28 +499,24 @@ with gr.Blocks(
                             placeholder="e.g., work, personal, ideas"
                         )
                         send_btn = gr.Button("📤 Send", variant="primary", size="lg")
-                
                 with gr.Row():
                     clear_response_btn = gr.Button("🗑️ Clear Response", variant="secondary")
                     show_context_btn = gr.Button("📋 Show Current Context", variant="secondary")
         
-        # HISTORY TAB
         with gr.Tab("📚 Chat History"):
             with gr.Group():
                 with gr.Row():
                     topic_filter = gr.Dropdown(
                         label="🔍 Filter by Topic",
-                        choices=["All Topics"],
+                        choices=get_topics_list(),
                         value="All Topics",
                         interactive=True
                     )
                     refresh_topics_btn = gr.Button("🔄 Refresh Topics", variant="secondary")
-                
                 with gr.Row():
                     show_history_btn = gr.Button("📖 Show Full History", variant="primary")
                     show_summary_btn = gr.Button("📋 Show Summary", variant="secondary")
                     clear_history_btn = gr.Button("🗑️ Clear All History", variant="stop")
-                
                 history_display = gr.Textbox(
                     label="📚 History & Summary",
                     lines=20,
@@ -275,109 +526,127 @@ with gr.Blocks(
                     placeholder="Chat history and summaries will appear here...",
                     elem_classes="history-display"
                 )
-    
-    # Event Handlers
-    def send_message(message, topic):
-        response, cleared_input = groq_with_memory(message, topic)
-        return response, cleared_input
-    
-    def show_current_context():
-        """Show current conversation context that AI can see"""
-        if not chat_history:
-            return "❌ No conversation context yet"
         
-        # Show actual context that will be sent to AI
-        messages = []
-        total_chars = 0
-        max_chars = 24000
-        
-        for msg in reversed(chat_history):
-            msg_chars = len(msg['content'])
-            if total_chars + msg_chars < max_chars:
-                messages.insert(0, msg)
-                total_chars += msg_chars
-            else:
-                break
-        
-        context_text = f"🧠 **Current AI Context** ({len(messages)} messages, ~{total_chars:,} chars)\n\n"
-        
-        for msg in messages:
-            role_icon = "👤" if msg["role"] == "user" else "🤖"
-            context_text += f"{role_icon} **{msg['timestamp']}** [{msg.get('topic', 'general')}]\n"
-            context_text += f"{msg['content'][:150]}{'...' if len(msg['content']) > 150 else ''}\n\n"
+        with gr.Tab("📊 Smart Analytics"):
+            with gr.Group():
+                gr.Markdown("### 🔍 Advanced Analysis of Your Conversations")
+                with gr.Row():
+                    analytics_btn = gr.Button("📊 Generate Analytics Report", variant="primary", size="lg")
+                    export_btn = gr.Button("💾 Export All Data", variant="secondary")
+                analytics_display = gr.Textbox(
+                    label="📊 Analytics Report",
+                    lines=25,
+                    max_lines=40,
+                    interactive=False,
+                    show_copy_button=True,
+                    placeholder="Analytics report will appear here...",
+                    elem_classes="analytics-display"
+                )
+                gr.Markdown("""
+                **Analytics Features:**
+                - 📈 Conversation patterns and trends
+                - 🏷️ Topic distribution analysis  
+                - ⏰ Activity patterns (daily/weekly/hourly)
+                - 😊 Mood and sentiment analysis
+                - 🔤 Most common words and phrases
+                - 📅 Historical trends and consistency
+                - 🎯 Productivity insights
+                """)
         
-        context_text += f"\n💡 *AI remembers {len(messages)} messages (~{total_chars:,} characters)*"
-        context_text += f"\n🔢 *Context limit: {max_chars:,} characters*"
-        return context_text
-    
-    def refresh_topic_choices():
-        return gr.Dropdown(choices=get_topics_list())
-    
-    def clear_only_response():
-        return ""
-    
-    def filter_and_show_history(topic_filter):
-        filter_topic = None if topic_filter == "All Topics" else topic_filter
-        return get_full_history(filter_topic)
-    
-    def filter_and_show_summary(topic_filter):
-        filter_topic = None if topic_filter == "All Topics" else topic_filter
-        return get_chat_summary(filter_topic)
+        with gr.Tab("⚙️ Data Management"):
+            with gr.Group():
+                gr.Markdown("### 💾 Persistent Storage Information")
+                storage_info = gr.Textbox(
+                    label="📂 Storage Status",
+                    value=f"💾 Storage Location: {STORAGE_DIR.absolute()}\n📁 History File: {HISTORY_FILE.name}\n📊 Analytics File: {ANALYTICS_FILE.name}\n📈 Messages Loaded: {len(storage.chat_history)}",
+                    lines=4,
+                    interactive=False
+                )
+                with gr.Row():
+                    refresh_storage_btn = gr.Button("🔄 Refresh Storage Info", variant="secondary")
+                    backup_btn = gr.Button("📦 Create Backup", variant="secondary")
+                export_display = gr.Textbox(
+                    label="📤 Export Data (JSON)",
+                    lines=15,
+                    max_lines=25,
+                    interactive=False,
+                    show_copy_button=True,
+                    placeholder="Exported data will appear here...",
+                    elem_classes="analytics-display"
+                )
     
-    # Button Events
+    # Event Handlers
     send_btn.click(
-        send_message,
-        inputs=[user_input, topic_input],
-        outputs=[ai_response, user_input]
-    )
-    
-    user_input.submit(
-        send_message,
+        fn=send_message,
         inputs=[user_input, topic_input],
         outputs=[ai_response, user_input]
     )
     
     clear_response_btn.click(
-        clear_only_response,
-        outputs=[ai_response]
+        fn=lambda: "",
+        inputs=None,
+        outputs=ai_response
     )
     
     show_context_btn.click(
-        show_current_context,
-        outputs=[ai_response]
+        fn=show_current_context,
+        inputs=None,
+        outputs=ai_response
+    )
+    
+    topic_filter.change(
+        fn=lambda x: x if x != "All Topics" else None,
+        inputs=topic_filter,
+        outputs=topic_filter
     )
     
     refresh_topics_btn.click(
-        refresh_topic_choices,
-        outputs=[topic_filter]
+        fn=get_topics_list,
+        inputs=None,
+        outputs=topic_filter
     )
     
     show_history_btn.click(
-        filter_and_show_history,
-        inputs=[topic_filter],
-        outputs=[history_display]
+        fn=get_full_history,
+        inputs=topic_filter,
+        outputs=history_display
     )
     
     show_summary_btn.click(
-        filter_and_show_summary,
-        inputs=[topic_filter],
-        outputs=[history_display]
+        fn=get_chat_summary,
+        inputs=topic_filter,
+        outputs=history_display
     )
     
     clear_history_btn.click(
-        clear_all_history,
-        outputs=[ai_response, user_input, history_display]
+        fn=clear_all_history,
+        inputs=None,
+        outputs=[history_display, analytics_display, export_display]
+    )
+    
+    analytics_btn.click(
+        fn=get_analytics_report,
+        inputs=None,
+        outputs=analytics_display
+    )
+    
+    export_btn.click(
+        fn=export_data,
+        inputs=None,
+        outputs=export_display
+    )
+    
+    refresh_storage_btn.click(
+        fn=lambda: f"💾 Storage Location: {STORAGE_DIR.absolute()}\n📁 History File: {HISTORY_FILE.name}\n📊 Analytics File: {ANALYTICS_FILE.name}\n📈 Messages Loaded: {len(storage.chat_history)}",
+        inputs=None,
+        outputs=storage_info
+    )
+    
+    backup_btn.click(
+        fn=storage.create_backup,
+        inputs=None,
+        outputs=storage_info
     )
 
-# Launch configuration
-print("🚀 Starting AI Journal Chat Interface...")
-print(f"🌐 Access at: http://localhost:7860")
-print(f"🔑 API Key: {'✅ Found' if API_KEY else '❌ Missing'}")
-
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True,
-        share=False
-    )
+# Launch the interface
+demo.launch()