Add Conversation Analysis Dashboard for Hugging Face Spaces

- Add conversation_analysis_app.py as main entry point
- Add conversation_analysis_ui.py with Gradio interface
- Update MongoDB configuration to use keshavchhaparia instance
- Add requirements.txt and README.md for HF Spaces
- Add migration script for MongoDB data
- Update .gitignore and add environment template

.gitignore

@@ -1,4 +1,4 @@
-# Environment files
+# Environment variables
 .env
 .env.local
 .env.production
@@ -27,7 +27,6 @@ wheels/
 
 # Virtual environments
 .venv/
-.venv-online/
 venv/
 ENV/
 env/
@@ -48,4 +47,4 @@ logs/
 
 # Temporary files
 *.tmp
-*.temp
+*.temp

Makefile

@@ -45,11 +45,13 @@ run_agent_app: check-config
 	uv run python -m tools.app --retriever-config-path=$(RETRIEVER_CONFIG) --ui
 
 run_agent_query: check-config
-	uv run python -m tools.app --retriever-config-path=$(RETRIEVER_CONFIG) --query "What's the difference between vector databases and vector indices?"
+	uv run python -m tools.app --retriever-config-path=$(RETRIEVER_CONFIG) --query "What pricing objections have been raised?"
 
 evaluate_agent: check-config
 	uv run python -m tools.evaluate_app --retriever-config-path=$(RETRIEVER_CONFIG)
 
+run_conversation_analysis_ui: # Launch Conversation Analysis Dashboard
+	uv run python conversation_analysis_app.py
 
 # --- QA ---
 

README.md

@@ -1,73 +1,51 @@
 ---
-title: Second Brain AI Assistant
-emoji: 🧠
+title: Conversation Analysis Dashboard
+emoji: 🎯
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: "5.12.0"
-app_file: app.py
+sdk_version: 4.0.0
+app_file: conversation_analysis_app.py
 pinned: false
 license: mit
+short_description: AI-powered conversation analysis with insights and summaries
 ---
 
-# Second Brain AI Assistant
+# 🎯 Conversation Analysis Dashboard
 
-A production-ready AI assistant that can answer questions about your documents using RAG (Retrieval-Augmented Generation).
+An AI-powered dashboard for analyzing customer conversations with intelligent insights, summaries, and follow-up email generation.
 
 ## Features
 
-- **Document Q&A**: Ask questions about your documents
-- **Source Attribution**: See which documents were used for each answer
-- **Clean UI**: Professional interface with proper formatting
-- **Real-time Processing**: Get answers instantly
-- **Tool Usage Display**: See which tools were used to generate responses
+- **📊 Conversation Analysis**: View and analyze customer conversations with quality scores and sentiment analysis
+- **💡 AI Insights**: Get marketing insights and key findings from conversations
+- **📧 Follow-up Emails**: Generate contextual follow-up emails based on conversation analysis
+- **🔍 Smart Filtering**: Filter conversations by quality score, sentiment, and search terms
+- **📈 Real-time Updates**: Dynamic table updates with conversation details
 
-## Usage
+## How to Use
 
-1. Enter your question in the text box
-2. Click "Ask" to get an AI-powered answer
-3. View sources and tools used in the response
-4. Use the debug section to see raw responses
+1. **View Conversations**: Browse through analyzed conversations in the main table
+2. **Filter Data**: Use the quality score slider, sentiment dropdown, and search box to filter conversations
+3. **View Details**: Click on any conversation row to see detailed analysis including:
+   - Contextual summary
+   - Marketing insights with quotes and sentiment
+   - Generated follow-up email
+4. **Refresh Data**: Use the refresh button to reload the latest conversation data
 
-## Example Queries
+## Technology Stack
 
-- "What pricing objections have been raised?"
-- "What messaging is resonating with prospects?"
-- "What concerns have prospects raised with regards to product?"
-- "What has resonated with prospects based on the meeting transcripts?"
+- **Frontend**: Gradio for interactive UI
+- **Backend**: Python with MongoDB for data storage
+- **AI**: OpenAI GPT models for conversation analysis
+- **Database**: MongoDB Atlas for conversation and RAG data storage
 
-## Configuration
+## Data Sources
 
-This space uses the following environment variables:
-- `OPENAI_API_KEY`: Your OpenAI API key
-- `MONGODB_URI`: MongoDB connection string
-- `MONGODB_DATABASE_NAME`: Database name (default: second_brain_course)
-- `MONGODB_COLLECTION_NAME`: Collection name (default: rag)
-- `COMET_API_KEY`: Comet ML API key for tracking
-- `COMET_PROJECT`: Project name (default: second_brain_course)
-- `RETRIEVER_CONFIG_PATH`: Path to retriever config (default: configs/compute_rag_vector_index_openai_contextual_simple.yaml)
+The dashboard analyzes conversations from MongoDB collections:
+- `test_intercom_data`: Main conversation data with analysis results
+- `rag_intercom`: RAG index for semantic search and context retrieval
 
-## Architecture
+## Getting Started
 
-- **RAG Pipeline**: Uses MongoDB for document storage and retrieval
-- **Embeddings**: OpenAI text-embedding-3-small for document embeddings
-- **LLM**: GPT-4o-mini for response generation
-- **UI**: Custom Gradio interface with enhanced formatting
-- **Tools**: MongoDB retriever and final answer tools
-
-## Local Development
-
-```bash
-# Install dependencies
-uv sync
-
-# Run the agent
-make run_agent_app
-
-# Or run directly
-python app.py
-```
-
-## License
-
-MIT License
+The app will automatically connect to the configured MongoDB instance and load conversation data. No additional setup required!

configs/conversation_analysis_app.yaml

@@ -0,0 +1,40 @@
+# Conversation Analysis App Configuration
+
+mongodb:
+  uri: "mongodb+srv://contextdb:HOqIgSH01CoEiMb1@cluster0.d9cmff.mongodb.net/"
+  database: "second_brain_course"
+  collection: "test_intercom_data"
+
+ui:
+  title: "Conversation Analysis Dashboard"
+  theme: "soft"
+  default_limit: 100
+  max_limit: 1000
+
+filters:
+  quality_score:
+    min: 0.0
+    max: 1.0
+    step: 0.01
+  sentiment_options: ["All", "Positive", "Negative", "Neutral", "Confused"]
+  search_fields: ["content", "conversation_analysis.aggregated_contextual_summary"]
+
+display:
+  summary_truncate: 100
+  date_format: "%Y-%m-%d %H:%M"
+  quality_colors:
+    high: "#28a745"    # Green
+    medium: "#ffc107"  # Yellow
+    low: "#dc3545"     # Red
+
+# MongoDB query optimization
+query:
+  default_limit: 100
+  max_limit: 1000
+  batch_size: 50
+
+# Error handling
+error_handling:
+  show_errors: true
+  log_level: "INFO"
+  retry_attempts: 3

conversation_analysis_app.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""
+Hugging Face Space app for Conversation Analysis Dashboard.
+
+This app displays conversation analysis results in a tabular format,
+showing insights, summaries, and follow-up emails for all conversations
+from the test_intercom_data collection.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add paths
+sys.path.append('.')
+sys.path.append('src')
+
+from second_brain_online.application.ui.conversation_analysis_ui import ConversationAnalysisUI
+
+def main():
+    """Main function for HF Space deployment."""
+    print("🚀 Starting Conversation Analysis Dashboard...")
+    print("📊 Loading conversation analysis data from MongoDB...")
+    
+    try:
+        # Initialize UI
+        ui = ConversationAnalysisUI()
+        
+        print("✅ UI initialized successfully")
+        print("🌐 Launching Gradio interface...")
+        
+        # Launch the interface
+        ui.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,
+            show_error=True
+        )
+        
+    except Exception as e:
+        print(f"❌ Error starting the application: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()

env_template.txt

@@ -0,0 +1,21 @@
+# Copy this to .env and fill in your actual values
+
+# MongoDB Configuration
+MONGODB_URI=mongodb+srv://keshavchhaparia:bUSBXeVCGWDyQhDG@saaslabs.awtivxf.mongodb.net/
+MONGODB_DATABASE_NAME=second_brain_course
+MONGODB_COLLECTION_NAME=rag_intercom
+
+# OpenAI Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Comet ML & Opik Configuration
+COMET_API_KEY=yPmLa7W6QyBODw1Pnfg9jqr7E
+COMET_PROJECT=second_brain_course
+
+# Hugging Face Configuration
+HUGGINGFACE_ACCESS_TOKEN=your_huggingface_token_here
+USE_HUGGINGFACE_DEDICATED_ENDPOINT=false
+HUGGINGFACE_DEDICATED_ENDPOINT=
+
+# Model Configuration
+OPENAI_MODEL_ID=gpt-4o

migrate_mongodb_data.py

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+"""
+Script to migrate test_intercom_data from contextdb instance to keshavchhaparia instance.
+"""
+
+import sys
+from pymongo import MongoClient
+from loguru import logger
+
+# Source MongoDB (contextdb instance)
+SOURCE_URI = "mongodb+srv://contextdb:HOqIgSH01CoEiMb1@cluster0.d9cmff.mongodb.net/"
+SOURCE_DB = "second_brain_course"
+SOURCE_COLLECTION = "test_intercom_data"
+
+# Target MongoDB (keshavchhaparia instance)
+TARGET_URI = "mongodb+srv://keshavchhaparia:bUSBXeVCGWDyQhDG@saaslabs.awtivxf.mongodb.net/"
+TARGET_DB = "second_brain_course"
+TARGET_COLLECTION = "test_intercom_data"
+
+def migrate_data():
+    """Migrate test_intercom_data collection from source to target MongoDB."""
+    
+    logger.info("🚀 Starting MongoDB data migration...")
+    
+    # Connect to source MongoDB
+    logger.info(f"📡 Connecting to source MongoDB: {SOURCE_URI}")
+    try:
+        source_client = MongoClient(SOURCE_URI)
+        source_db = source_client[SOURCE_DB]
+        source_collection = source_db[SOURCE_COLLECTION]
+        logger.info("✅ Connected to source MongoDB")
+    except Exception as e:
+        logger.error(f"❌ Failed to connect to source MongoDB: {e}")
+        return False
+    
+    # Connect to target MongoDB
+    logger.info(f"📡 Connecting to target MongoDB: {TARGET_URI}")
+    try:
+        target_client = MongoClient(TARGET_URI)
+        target_db = target_client[TARGET_DB]
+        target_collection = target_db[TARGET_COLLECTION]
+        logger.info("✅ Connected to target MongoDB")
+    except Exception as e:
+        logger.error(f"❌ Failed to connect to target MongoDB: {e}")
+        return False
+    
+    try:
+        # Get document count from source
+        source_count = source_collection.count_documents({})
+        logger.info(f"📊 Source collection has {source_count} documents")
+        
+        if source_count == 0:
+            logger.warning("⚠️ Source collection is empty, nothing to migrate")
+            return True
+        
+        # Delete existing target collection
+        logger.info(f"🗑️ Deleting existing target collection: {TARGET_COLLECTION}")
+        target_collection.drop()
+        logger.info("✅ Target collection deleted")
+        
+        # Copy documents from source to target
+        logger.info("📋 Copying documents from source to target...")
+        
+        # Process in batches to avoid memory issues
+        batch_size = 100
+        total_copied = 0
+        
+        for skip in range(0, source_count, batch_size):
+            # Get batch of documents
+            documents = list(source_collection.find().skip(skip).limit(batch_size))
+            
+            if documents:
+                # Insert batch into target
+                target_collection.insert_many(documents)
+                total_copied += len(documents)
+                logger.info(f"📦 Copied batch: {len(documents)} documents (Total: {total_copied}/{source_count})")
+        
+        # Verify migration
+        target_count = target_collection.count_documents({})
+        logger.info(f"✅ Migration completed! Target collection has {target_count} documents")
+        
+        if target_count == source_count:
+            logger.info("🎉 Migration successful - document counts match!")
+            return True
+        else:
+            logger.error(f"❌ Migration failed - document count mismatch: {target_count} vs {source_count}")
+            return False
+            
+    except Exception as e:
+        logger.error(f"❌ Migration failed: {e}")
+        return False
+    
+    finally:
+        # Close connections
+        source_client.close()
+        target_client.close()
+        logger.info("🔌 MongoDB connections closed")
+
+def verify_migration():
+    """Verify the migration was successful."""
+    logger.info("🔍 Verifying migration...")
+    
+    try:
+        # Connect to target MongoDB
+        target_client = MongoClient(TARGET_URI)
+        target_db = target_client[TARGET_DB]
+        target_collection = target_db[TARGET_COLLECTION]
+        
+        # Get sample documents
+        sample_docs = list(target_collection.find().limit(3))
+        logger.info(f"📋 Sample documents in target collection:")
+        
+        for i, doc in enumerate(sample_docs, 1):
+            conversation_id = doc.get('metadata', {}).get('properties', {}).get('conversation_id', 'N/A')
+            has_analysis = 'conversation_analysis' in doc
+            quality_score = doc.get('content_quality_score', 'N/A')
+            logger.info(f"  {i}. Conversation ID: {conversation_id}, Has Analysis: {has_analysis}, Quality: {quality_score}")
+        
+        target_client.close()
+        logger.info("✅ Verification completed")
+        
+    except Exception as e:
+        logger.error(f"❌ Verification failed: {e}")
+
+if __name__ == "__main__":
+    logger.info("=" * 60)
+    logger.info("🔄 MongoDB Data Migration Script")
+    logger.info("=" * 60)
+    
+    # Run migration
+    success = migrate_data()
+    
+    if success:
+        # Verify migration
+        verify_migration()
+        logger.info("🎉 Migration completed successfully!")
+    else:
+        logger.error("❌ Migration failed!")
+        sys.exit(1)

requirements.txt

@@ -1,15 +1,6 @@
-loguru>=0.7.3
-pydantic>=2.8.2
-pydantic-settings>=2.7.0
-pymongo>=4.10.1
-boto3>=1.36.0
-langchain>=0.3.14
-langchain-mongodb>=0.4.0
-langchain-openai>=0.3.1
-langchain-core>=0.3.30
-gradio>=5.12.0
-smolagents==1.4.1
-opik>=1.4.2
-comet_ml>=3.47.6
-langchain-huggingface>=0.1.2
-huggingface-hub>=0.27.1
+gradio>=4.0.0
+pymongo>=4.0.0
+pandas>=1.5.0
+python-dotenv>=1.0.0
+opik>=0.1.0
+loguru>=0.7.0

src/second_brain_online/application/ui/conversation_analysis_ui.py

@@ -0,0 +1,376 @@
+import gradio as gr
+import pandas as pd
+from pymongo import MongoClient
+from typing import List, Dict, Any, Optional, Tuple
+from datetime import datetime
+import json
+import re
+
+class ConversationAnalysisUI:
+    """Gradio UI for displaying conversation analysis results."""
+    
+    def __init__(self):
+        # Use keshavchhaparia MongoDB instance (same as RAG system)
+        self.mongodb_uri = "mongodb+srv://keshavchhaparia:bUSBXeVCGWDyQhDG@saaslabs.awtivxf.mongodb.net/"
+        self.database_name = "second_brain_course"
+        self.collection_name = "test_intercom_data"
+        
+        self.setup_mongodb()
+        self.setup_ui()
+    
+    def setup_mongodb(self):
+        """Initialize MongoDB connection."""
+        try:
+            self.client = MongoClient(self.mongodb_uri)
+            self.db = self.client[self.database_name]
+            self.collection = self.db[self.collection_name]
+            print(f"✅ Connected to MongoDB: {self.database_name}.{self.collection_name}")
+        except Exception as e:
+            print(f"❌ MongoDB connection failed: {e}")
+            raise
+    
+    def load_conversations(self, 
+                          quality_min: float = 0.0, 
+                          quality_max: float = 1.0,
+                          sentiment: str = "All",
+                          search_text: str = "",
+                          limit: int = 100) -> pd.DataFrame:
+        """Load and filter conversations."""
+        try:
+            # Build query
+            query = {
+                'conversation_analysis': {'$exists': True, '$ne': None},
+                'content_quality_score': {'$gte': quality_min, '$lte': quality_max}
+            }
+            
+            # Add sentiment filter
+            if sentiment != "All":
+                query['conversation_analysis.aggregated_marketing_insights.quotes.sentiment'] = sentiment
+            
+            # Add text search
+            if search_text:
+                query['$or'] = [
+                    {'content': {'$regex': search_text, '$options': 'i'}},
+                    {'conversation_analysis.aggregated_contextual_summary': {'$regex': search_text, '$options': 'i'}}
+                ]
+            
+            # Fetch documents
+            docs = list(self.collection.find(query).limit(limit))
+            
+            # Convert to DataFrame
+            data = []
+            seen_conversation_ids = set()
+            
+            for doc in docs:
+                conversation_id = doc.get('metadata', {}).get('properties', {}).get('conversation_id', 'N/A')
+                
+                # Skip duplicates
+                if conversation_id in seen_conversation_ids:
+                    continue
+                seen_conversation_ids.add(conversation_id)
+                
+                analysis = doc.get('conversation_analysis', {})
+                insights = analysis.get('aggregated_marketing_insights', {})
+                quotes = insights.get('quotes', [])
+                
+                # Extract primary sentiment
+                primary_sentiment = quotes[0].get('sentiment', 'Unknown') if quotes else 'Unknown'
+                
+                # Format date
+                created_at = analysis.get('created_at', '')
+                if isinstance(created_at, str):
+                    try:
+                        # Parse and format date
+                        dt = datetime.fromisoformat(created_at.replace('Z', '+00:00'))
+                        formatted_date = dt.strftime('%b %d, %Y %H:%M')
+                    except:
+                        formatted_date = created_at
+                elif hasattr(created_at, 'strftime'):
+                    formatted_date = created_at.strftime('%b %d, %Y %H:%M')
+                else:
+                    formatted_date = str(created_at)
+                
+                # Get full summary without truncation
+                full_summary = analysis.get('aggregated_contextual_summary', 'No summary available')
+                
+                # Get a simple insights summary for the table
+                marketing_insights = analysis.get('aggregated_marketing_insights', {})
+                insights_count = 0
+                
+                if isinstance(marketing_insights, dict):
+                    quotes_count = len(marketing_insights.get('quotes', []))
+                    findings_count = len(marketing_insights.get('key_findings', []))
+                    insights_count = quotes_count + findings_count
+                
+                insights_text = f"{insights_count} insights available" if insights_count > 0 else "No insights available"
+                
+                data.append({
+                    'conversation_id': conversation_id,
+                    'quality_score': round(doc.get('content_quality_score', 0.0), 2),
+                    'sentiment': primary_sentiment,
+                    'summary': full_summary,
+                    'insights': insights_text,
+                    'date': formatted_date
+                })
+            
+            return pd.DataFrame(data)
+            
+        except Exception as e:
+            print(f"❌ Error loading conversations: {e}")
+            return pd.DataFrame()
+    
+    def get_conversation_details(self, conversation_id: str) -> str:
+        """Get detailed analysis for a specific conversation."""
+        try:
+            doc = self.collection.find_one({
+                'metadata.properties.conversation_id': conversation_id,
+                'conversation_analysis': {'$exists': True}
+            })
+            
+            if not doc:
+                return "<p>❌ Conversation not found</p>"
+            
+            analysis = doc.get('conversation_analysis', {})
+            insights = analysis.get('aggregated_marketing_insights', {})
+            
+            # Format the HTML content
+            html_content = f"""
+            <div class="conversation-details">
+                <h3>📄 Conversation Analysis: {conversation_id}</h3>
+                
+                <div class="section">
+                    <h4>📝 Summary (Contextual Summary)</h4>
+                    <div class="content-box">
+                        <p>{analysis.get('aggregated_contextual_summary', 'No summary available')}</p>
+                    </div>
+                </div>
+                
+                <div class="section">
+                    <h4>💡 Insights</h4>
+            """
+            
+            # Add quotes
+            quotes = insights.get('quotes', [])
+            if quotes:
+                html_content += "<h5>📝 Key Quotes:</h5><ul>"
+                for i, quote in enumerate(quotes, 1):
+                    sentiment_class = f"sentiment-{quote.get('sentiment', 'neutral').lower()}"
+                    html_content += f"""
+                    <li>
+                        <div class="quote-item">
+                            <p><strong>Quote {i}:</strong> "{quote.get('quote', '')}"</p>
+                            <p><strong>Context:</strong> {quote.get('context', '')}</p>
+                            <p><strong>Sentiment:</strong> <span class="{sentiment_class}">{quote.get('sentiment', 'Unknown')}</span></p>
+                        </div>
+                    </li>
+                    """
+                html_content += "</ul>"
+            
+            # Add key findings
+            findings = insights.get('key_findings', [])
+            if findings:
+                html_content += "<h5>🔍 Key Findings:</h5><ul>"
+                for i, finding in enumerate(findings, 1):
+                    impact_class = f"impact-{finding.get('impact', 'medium').lower()}"
+                    html_content += f"""
+                    <li>
+                        <div class="finding-item">
+                            <p><strong>Finding {i}:</strong> {finding.get('finding', '')}</p>
+                            <p><strong>Evidence:</strong> {finding.get('evidence', '')}</p>
+                            <p><strong>Impact:</strong> <span class="{impact_class}">{finding.get('impact', 'Unknown')}</span></p>
+                        </div>
+                    </li>
+                    """
+                html_content += "</ul>"
+            
+            # Add follow-up email
+            follow_up_email = analysis.get('follow_up_email', '')
+            if follow_up_email:
+                html_content += f"""
+                <div class="section">
+                    <h4>📧 Follow-up Email</h4>
+                    <div class="content-box">
+                        <pre>{follow_up_email}</pre>
+                    </div>
+                </div>
+                """
+            
+            html_content += "</div>"
+            
+            return html_content
+            
+        except Exception as e:
+            return f"<p>❌ Error loading conversation details: {e}</p>"
+    
+    def setup_ui(self):
+        """Setup the Gradio interface."""
+        with gr.Blocks(
+            title="Conversation Analysis Dashboard",
+            theme=gr.themes.Soft(),
+            css="""
+            .conversation-details {
+                max-width: 100%;
+                padding: 20px;
+            }
+            .section {
+                margin: 20px 0;
+                padding: 15px;
+                border: 1px solid #e0e0e0;
+                border-radius: 8px;
+                background-color: #f8f9fa;
+            }
+            .content-box {
+                background-color: white;
+                padding: 15px;
+                border-radius: 5px;
+                border: 1px solid #dee2e6;
+                margin: 10px 0;
+            }
+            .quote-item, .finding-item {
+                margin: 10px 0;
+                padding: 10px;
+                background-color: white;
+                border-radius: 5px;
+                border-left: 4px solid #007bff;
+            }
+            .sentiment-positive { 
+                background-color: #d4edda; 
+                color: #155724; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .sentiment-negative { 
+                background-color: #f8d7da; 
+                color: #721c24; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .sentiment-neutral { 
+                background-color: #d1ecf1; 
+                color: #0c5460; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .sentiment-confused { 
+                background-color: #fff3cd; 
+                color: #856404; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .impact-high { 
+                background-color: #f8d7da; 
+                color: #721c24; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .impact-medium { 
+                background-color: #fff3cd; 
+                color: #856404; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .impact-low { 
+                background-color: #d4edda; 
+                color: #155724; 
+                padding: 2px 8px;
+                border-radius: 4px;
+                font-weight: bold;
+            }
+            .quality-high { color: #28a745; font-weight: bold; }
+            .quality-medium { color: #ffc107; font-weight: bold; }
+            .quality-low { color: #dc3545; font-weight: bold; }
+            """
+        ) as self.interface:
+            
+            gr.Markdown("# 🎯 Conversation Analysis Dashboard")
+            gr.Markdown("Analyze customer conversations with AI-powered insights, summaries, and follow-up emails.")
+            
+            # Filters
+            with gr.Row():
+                with gr.Column(scale=2):
+                    quality_range = gr.Slider(
+                        minimum=0.0, maximum=1.0, value=[0.0, 1.0],
+                        label="Quality Score Range", step=0.01
+                    )
+                with gr.Column(scale=1):
+                    sentiment_filter = gr.Dropdown(
+                        choices=["All", "Positive", "Negative", "Neutral", "Confused"],
+                        value="All", label="Sentiment Filter"
+                    )
+                with gr.Column(scale=1):
+                    search_text = gr.Textbox(
+                        placeholder="Search conversations...", label="Search"
+                    )
+                with gr.Column(scale=1):
+                    refresh_btn = gr.Button("🔄 Refresh", variant="primary")
+            
+            # Main table
+            with gr.Row():
+                conversations_df = gr.Dataframe(
+                    headers=["Conversation ID", "Quality", "Sentiment", "Summary", "Insights Count", "Date"],
+                    datatype=["str", "number", "str", "str", "str", "str"],
+                    interactive=False,
+                    label="Conversations",
+                    wrap=True,  # Enable text wrapping
+                    max_height=600  # Set max height for scrolling
+                )
+            
+            # Detail view
+            with gr.Row():
+                with gr.Column():
+                    detail_view = gr.HTML(
+                        value="<p>Select a conversation from the table above to view detailed analysis</p>",
+                        label="Conversation Details"
+                    )
+            
+            # Event handlers
+            def refresh_data(quality_range, sentiment, search):
+                if isinstance(quality_range, (list, tuple)) and len(quality_range) == 2:
+                    quality_min, quality_max = quality_range
+                else:
+                    quality_min, quality_max = 0.0, 1.0
+                df = self.load_conversations(quality_min, quality_max, sentiment, search, limit=1000)
+                return df
+            
+            def on_table_select(evt: gr.SelectData):
+                if evt.index[0] is not None:
+                    try:
+                        # Get the conversation ID from the selected row
+                        # We need to get the current dataframe from the table
+                        current_df = self.load_conversations()
+                        if not current_df.empty and evt.index[0] < len(current_df):
+                            conversation_id = current_df.iloc[evt.index[0]]['conversation_id']
+                            return self.get_conversation_details(conversation_id)
+                        else:
+                            return "<p>Please refresh the data first</p>"
+                    except Exception as e:
+                        return f"<p>Error: {e}</p>"
+                return "<p>Please select a conversation from the table</p>"
+            
+            refresh_btn.click(
+                fn=refresh_data,
+                inputs=[quality_range, sentiment_filter, search_text],
+                outputs=[conversations_df]
+            )
+            
+            conversations_df.select(
+                fn=on_table_select,
+                outputs=[detail_view]
+            )
+            
+            # Load initial data when the page loads
+            def load_initial_data():
+                return self.load_conversations(limit=1000)  # Load more conversations
+            
+            # Set initial data using the interface's load event
+            self.interface.load(load_initial_data, outputs=[conversations_df])
+    
+    def launch(self, **kwargs):
+        """Launch the Gradio interface."""
+        self.interface.launch(**kwargs)

src/second_brain_online/config.py

@@ -44,7 +44,7 @@ class Settings(BaseSettings):
         description="Name of the MongoDB database.",
     )
     MONGODB_COLLECTION_NAME: str = Field(
-        default="rag_insights_test",
+        default="rag_intercom",
         description="Name of the MongoDB collection for RAG documents.",
     )
     MONGODB_URI: str = Field(