update new version of app

.claude/settings.local.json

@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

.env

@@ -0,0 +1 @@
+OPENROUTER_API_KEY=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

.gradio/certificate.pem

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

.gradio/flagged/dataset1.csv

@@ -0,0 +1,2 @@
+name,output,timestamp
+ddd,Hello ddd!,2025-09-07 16:28:01.266019

.gradio/flagged/dataset2.csv

@@ -0,0 +1,2 @@
+output,timestamp
+"{""type"": ""matplotlib"", ""plot"": ""data:image/webp;base64,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""}",2025-09-07 17:34:58.244504

Dockerfile

@@ -35,4 +35,4 @@ RUN mkdir -p /code/cache
 EXPOSE 7860
 
 # Run the application
-CMD ["python", "app.py"]
+CMD ["python", "app1.py"]

README.md

@@ -1,13 +1,41 @@
----
-title: Dash Mcp
-emoji: 🏢
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Dash MCP - AI-Powered Data Analytics Dashboard
+
+🤖 An interactive data analytics dashboard built with Dash and powered by AI assistance.
+
+## Features
+
+- **Interactive Data Visualization**: Create various chart types (scatter, line, bar, histogram, box, heatmap, pie)
+- **Built-in Sample Datasets**: Gapminder, Iris, Tips, Stock Data, and Wind Data
+- **CSV/Excel Upload**: Upload and analyze your own datasets
+- **AI-Powered Analysis**: Ask questions about your data and get intelligent responses
+- **Multiple Tabs**: Organized interface for dataset management, AI assistant, visualizations, and data exploration
+
+## Quick Start
+
+1. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. Set up environment variables (optional for enhanced AI features):
+   ```bash
+   echo "OPENROUTER_API_KEY=your_key_here" > .env
+   ```
+
+3. Run the application:
+   ```bash
+   python app.py
+   ```
+
+4. Open your browser to `http://localhost:7860`
+
+## Tech Stack
+
+- **Frontend**: Dash, Plotly, Bootstrap Components
+- **Backend**: Python, Pandas, NumPy
+- **AI**: LangChain, OpenRouter API
+- **Data Processing**: Pandas, Plotly Express
+
+## License
+
+MIT

ai_assistant.py

@@ -0,0 +1,881 @@
+"""
+AI Assistant Module for Data Analytics Dashboard
+
+This module contains all AI-related functionality including:
+- LLM integrations (OpenRouter, OpenAI, etc.)
+- Data analysis functions
+- Natural language processing
+- Chart generation from prompts
+- Advanced analytics
+"""
+
+import os
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from typing import Optional, Dict, Any, List, Tuple
+from dotenv import load_dotenv
+import sys
+import io
+import contextlib
+
+# Configure matplotlib for non-interactive backend to avoid GUI issues
+import matplotlib
+matplotlib.use('Agg')  # Use non-interactive backend
+import matplotlib.pyplot as plt
+import traceback
+import re
+import numpy as np
+import seaborn as sns
+from io import StringIO, BytesIO
+import base64
+
+# Load environment variables
+load_dotenv()
+
+# LangChain imports (only import what we need)
+try:
+    from langchain_core.prompts import PromptTemplate
+    # Try the newer langchain-openai first, fallback to community
+    try:
+        from langchain_openai import ChatOpenAI
+    except ImportError:
+        from langchain_community.chat_models import ChatOpenAI
+    LANGCHAIN_AVAILABLE = True
+except ImportError:
+    print("LangChain not fully available - using demo mode")
+    LANGCHAIN_AVAILABLE = False
+
+class PythonREPL:
+    """Safe Python code execution environment for AI assistant"""
+    
+    def __init__(self, dataframe=None):
+        self.df = dataframe
+        self.globals_dict = {
+            # Safe imports
+            'pd': pd,
+            'np': np,
+            'plt': plt,
+            'sns': sns,
+            'px': px,
+            'go': go,
+            # Built-in functions (safe subset)
+            'len': len,
+            'sum': sum,
+            'min': min,
+            'max': max,
+            'abs': abs,
+            'round': round,
+            'range': range,
+            'list': list,
+            'dict': dict,
+            'tuple': tuple,
+            'set': set,
+            'str': str,
+            'int': int,
+            'float': float,
+            'bool': bool,
+            # Data analysis functions
+            'print': print,
+        }
+        
+        if dataframe is not None:
+            self.globals_dict['df'] = dataframe
+    
+    def execute_code(self, code: str) -> Dict[str, Any]:
+        """Execute Python code safely and return results"""
+        # Capture stdout
+        stdout_capture = StringIO()
+        result = {
+            'success': False,
+            'output': '',
+            'error': '',
+            'plots': [],
+            'returned_value': None
+        }
+        
+        try:
+            # Security check - block potentially dangerous operations
+            if self._is_code_safe(code):
+                with contextlib.redirect_stdout(stdout_capture):
+                    # Create a copy of globals for this execution
+                    local_globals = self.globals_dict.copy()
+                    
+                    # Execute the code
+                    exec(code, local_globals)
+                    
+                    result['success'] = True
+                    result['output'] = stdout_capture.getvalue()
+                    
+                    # Check if any plots were created (matplotlib)
+                    if plt.get_fignums():
+                        plot_data = self._capture_plots()
+                        result['plots'] = plot_data
+            else:
+                result['error'] = "Code contains potentially unsafe operations and cannot be executed."
+                
+        except Exception as e:
+            result['error'] = f"Error: {str(e)}\n{traceback.format_exc()}"
+        
+        return result
+    
+    def _is_code_safe(self, code: str) -> bool:
+        """Check if code is safe to execute"""
+        # List of potentially dangerous patterns
+        dangerous_patterns = [
+            r'import\s+os',
+            r'import\s+sys',
+            r'import\s+subprocess',
+            r'import\s+shutil',
+            r'from\s+os',
+            r'from\s+sys',
+            r'from\s+subprocess',
+            r'__import__',
+            r'eval\s*\(',
+            r'exec\s*\(',
+            r'open\s*\(',
+            r'file\s*\(',
+            r'input\s*\(',
+            r'raw_input\s*\(',
+            r'exit\s*\(',
+            r'quit\s*\(',
+            r'del\s+',
+            r'globals\s*\(',
+            r'locals\s*\(',
+            r'vars\s*\(',
+            r'reload\s*\(',
+            r'pd\.read_csv\s*\(',
+            r'pd\.read_excel\s*\(',
+            r'pd\.read_json\s*\(',
+            r'pandas\.read_csv\s*\(',
+            r'pandas\.read_excel\s*\(',
+            r'pandas\.read_json\s*\(',
+            r'["\'][^"\']*\.csv["\']',  # Only block actual file paths like "file.csv"
+            r'["\'][^"\']*\.xlsx["\']', # Only block actual file paths like "file.xlsx"
+            r'["\'][^"\']*\.json["\']', # Only block actual file paths like "file.json"
+            r'your_data_file',
+        ]
+        
+        code_lower = code.lower()
+        for pattern in dangerous_patterns:
+            if re.search(pattern, code_lower):
+                return False
+        
+        return True
+    
+    def _capture_plots(self) -> List[str]:
+        """Capture matplotlib plots as base64 encoded images"""
+        plots = []
+        
+        for fig_num in plt.get_fignums():
+            fig = plt.figure(fig_num)
+            
+            # Save plot to BytesIO
+            img_buffer = BytesIO()
+            fig.savefig(img_buffer, format='png', bbox_inches='tight', dpi=150)
+            img_buffer.seek(0)
+            
+            # Convert to base64
+            img_base64 = base64.b64encode(img_buffer.getvalue()).decode()
+            plots.append(img_base64)
+            
+            # Close the figure to free memory
+            plt.close(fig)
+        
+        return plots
+
+class ChatOpenRouter:
+    """Custom ChatOpenRouter class for OpenRouter API integration"""
+    
+    def __init__(self, model="google/gemma-3-27b-it:free", temperature=0.3, max_tokens=1500, **kwargs):
+        self.model = model
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.api_key = os.environ.get("OPENROUTER_API_KEY")
+        
+        if not self.api_key:
+            raise ValueError("OPENROUTER_API_KEY not found in environment variables")
+        
+        if LANGCHAIN_AVAILABLE:
+            self.client = ChatOpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=self.api_key,
+                model=model,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+        else:
+            self.client = None
+    
+    def invoke(self, messages):
+        """Invoke the model with messages"""
+        if self.client:
+            return self.client.invoke(messages)
+        else:
+            # Fallback response if LangChain not available
+            return type('Response', (), {'content': 'LangChain not available - using demo mode'})()
+    
+    def is_available(self):
+        """Check if the client is properly initialized"""
+        return self.client is not None and self.api_key is not None
+
+class AIAssistant:
+    """Main AI Assistant class that handles various AI-powered data analysis tasks"""
+    
+    def __init__(self):
+        self.llm_client = None
+        self.openrouter_available = self._init_openrouter()
+        self.current_dataset = None
+        self.dataset_context = {}
+        self.python_repl = None
+    
+    def _init_openrouter(self) -> bool:
+        """Initialize OpenRouter LLM if API key is available"""
+        try:
+            self.llm_client = ChatOpenRouter()
+            if self.llm_client.is_available():
+                print("✅ OpenRouter initialized successfully")
+                return True
+            else:
+                print("⚠️ OpenRouter client not fully available - using demo mode")
+                return False
+            
+        except Exception as e:
+            print(f"❌ Failed to initialize OpenRouter: {e}")
+            print("Using demo mode instead")
+            return False
+    
+    def set_dataset(self, df: pd.DataFrame, dataset_name: str = "current"):
+        """Set the current dataset for AI analysis"""
+        self.current_dataset = df
+        self.dataset_context[dataset_name] = {
+            'dataframe': df,
+            'shape': df.shape,
+            'columns': df.columns.tolist(),
+            'dtypes': df.dtypes.to_dict(),
+            'missing_values': df.isnull().sum().to_dict(),
+            'numeric_columns': df.select_dtypes(include=['number']).columns.tolist(),
+            'categorical_columns': df.select_dtypes(include=['object']).columns.tolist(),
+            'summary_stats': df.describe().to_dict() if len(df.select_dtypes(include=['number']).columns) > 0 else {}
+        }
+        # Initialize Python REPL with the dataset
+        self.python_repl = PythonREPL(dataframe=df)
+    
+    def get_llm_response(self, question: str, df: pd.DataFrame) -> str:
+        """Generate LLM-powered response using OpenRouter"""
+        if not self.openrouter_available or not self.llm_client:
+            return self.get_basic_response(question, df)
+        
+        try:
+            # Check if user is asking for code execution or analysis that would benefit from code
+            if self._should_execute_code(question):
+                return self._get_code_execution_response(question, df)
+            
+            # Create data context for the LLM
+            data_context = self._create_data_context(df)
+            
+            # Enhanced prompt with code execution capability
+            prompt = f"""You are a professional data analyst AI assistant with Python code execution capabilities. Based on the provided dataset information, answer the user's question with clear, actionable insights.
+
+Dataset Context:
+{data_context}
+
+User Question: {question}
+
+Available capabilities:
+- You can write and execute Python code to analyze the data
+- The dataset is available as 'df' variable
+- Available libraries: pandas (pd), numpy (np), matplotlib (plt), seaborn (sns), plotly (px, go)
+- You can create visualizations and perform complex analyses
+
+Response format:
+1. Direct answer to the question based on the actual data
+2. Key insights or patterns you notice in this specific dataset
+3. If analysis requires computation, suggest or provide Python code
+4. Practical recommendations or next steps if applicable
+5. Use emojis and markdown formatting to make your response engaging and easy to read
+
+Keep your response concise but informative, focusing on actionable insights about this specific dataset.
+"""
+            
+            # Get response from OpenRouter
+            response = self.llm_client.invoke(prompt)
+            
+            # Extract content
+            if hasattr(response, 'content'):
+                return response.content
+            else:
+                return str(response)
+                
+        except Exception as e:
+            print(f"Error getting LLM response: {e}")
+            return self.get_basic_response(question, df)
+    
+    def _create_data_context(self, df: pd.DataFrame) -> str:
+        """Create comprehensive data context for LLM"""
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        categorical_cols = df.select_dtypes(include=['object']).columns
+        
+        context = f"""Dataset Information:
+- Shape: {df.shape[0]:,} rows × {df.shape[1]} columns
+- Columns: {', '.join(df.columns.tolist())}
+- Numeric columns ({len(numeric_cols)}): {', '.join(numeric_cols.tolist())}
+- Categorical columns ({len(categorical_cols)}): {', '.join(categorical_cols.tolist())}
+- Missing values: {df.isnull().sum().sum()} total
+
+Sample Data (first 3 rows):
+{df.head(3).to_string()}
+
+Summary Statistics (numeric columns):
+{df.describe().to_string() if len(numeric_cols) > 0 else 'No numeric columns for statistics'}
+
+Data Types:
+{df.dtypes.to_string()}"""
+        
+        return context
+    
+    def _should_execute_code(self, question: str) -> bool:
+        """Determine if the question requires code execution"""
+        code_keywords = [
+            'run code', 'execute', 'calculate', 'compute', 'plot', 'visualize', 'graph',
+            'correlation matrix', 'regression', 'analysis', 'statistics', 'distribution',
+            'histogram', 'scatter plot', 'bar chart', 'create chart', 'show me',
+            'python code', 'pandas', 'numpy'
+        ]
+        
+        question_lower = question.lower()
+        return any(keyword in question_lower for keyword in code_keywords)
+    
+    def _get_code_execution_response(self, question: str, df: pd.DataFrame) -> str:
+        """Generate response with code execution"""
+        if not self.python_repl:
+            return "Code execution environment not available. Please load a dataset first."
+        
+        # Create a prompt to generate code for the user's request
+        code_prompt = f"""You are a Python data analyst. Generate Python code to answer this question about the dataset:
+
+Question: {question}
+
+IMPORTANT - Dataset is already loaded:
+- The dataset is already loaded and available as the variable 'df'
+- DO NOT use pd.read_csv() or any file loading commands
+- DO NOT try to load data from files - it's already available as 'df'
+- The dataframe 'df' contains {df.shape[0]} rows and {df.shape[1]} columns
+- Columns available in df: {df.columns.tolist()}
+
+Sample data from df:
+{df.head(3).to_string()}
+
+Requirements:
+1. Use the pre-loaded dataframe 'df' directly
+2. Write clean, well-commented Python code
+3. Use pandas, numpy, matplotlib, seaborn as needed
+4. Include print statements to show results
+5. Create visualizations if requested
+6. DO NOT use plt.show() - plots are automatically captured
+7. Only return the Python code, no explanations
+
+Code:"""
+        
+        try:
+            # Get code from LLM
+            response = self.llm_client.invoke(code_prompt)
+            generated_code = response.content if hasattr(response, 'content') else str(response)
+            
+            # Extract Python code from the response
+            code = self._extract_code_from_response(generated_code)
+            
+            if code:
+                # Execute the code
+                result = self.python_repl.execute_code(code)
+                
+                # Format the response
+                return self._format_code_execution_result(question, code, result)
+            else:
+                return f"I couldn't generate appropriate code for your request: {question}"
+                
+        except Exception as e:
+            return f"Error generating code execution response: {str(e)}"
+    
+    def _extract_code_from_response(self, response: str) -> str:
+        """Extract Python code from LLM response"""
+        # Look for code blocks
+        code_patterns = [
+            r'```python\s*\n(.*?)\n```',
+            r'```\s*\n(.*?)\n```',
+            r'`([^`]+)`'
+        ]
+        
+        for pattern in code_patterns:
+            matches = re.findall(pattern, response, re.DOTALL)
+            if matches:
+                code_result = matches[0].strip()
+                # Remove plt.show() calls as they don't work with non-GUI backend
+                code_result = re.sub(r'plt\.show\(\)\s*', '', code_result)
+                return code_result
+        
+        # If no code blocks found, assume the entire response is code
+        lines = response.strip().split('\n')
+        code_lines = []
+        
+        for line in lines:
+            # Skip common non-code patterns
+            if any(skip in line.lower() for skip in ['here', 'this code', 'explanation', 'result']):
+                continue
+            if line.strip().startswith(('#', '//', '/*')):
+                continue
+            code_lines.append(line)
+        
+        code_result = '\n'.join(code_lines).strip()
+        
+        # Remove plt.show() calls as they don't work with non-GUI backend
+        code_result = re.sub(r'plt\.show\(\)\s*', '', code_result)
+        
+        return code_result
+    
+    def _format_code_execution_result(self, question: str, code: str, result: Dict[str, Any]) -> str:
+        """Format the code execution result for display"""
+        response_parts = [
+            f"## 🐍 **Code Execution Result**",
+            f"**Question:** {question}",
+            "",
+            "### **Code:**",
+            f"```python",
+            code,
+            "```",
+            ""
+        ]
+        
+        if result['success']:
+            if result['output']:
+                response_parts.extend([
+                    "### **Output:**",
+                    "```",
+                    result['output'],
+                    "```",
+                    ""
+                ])
+            
+            if result['plots']:
+                response_parts.extend([
+                    "### **Generated Plots:**",
+                    f"📊 {len(result['plots'])} plot(s) created.",
+                    ""
+                ])
+                
+                # Add each plot as a base64 image
+                for i, plot_base64 in enumerate(result['plots'], 1):
+                    response_parts.extend([
+                        f"**Plot {i}:**",
+                        f"![Plot {i}](data:image/png;base64,{plot_base64})",
+                        ""
+                    ])
+        else:
+            response_parts.extend([
+                "### **❌ Error:**",
+                "```",
+                result['error'],
+                "```",
+                ""
+            ])
+        
+        return "\n".join(response_parts)
+    
+    def get_basic_response(self, question: str, df: pd.DataFrame) -> str:
+        """Generate a basic AI response for demo mode"""
+        
+        # Basic question patterns and responses
+        question_lower = question.lower()
+        
+        # Data overview questions
+        if any(word in question_lower for word in ['overview', 'summary', 'describe', 'about']):
+            return self._generate_data_overview(df)
+        
+        # Missing data questions
+        elif any(word in question_lower for word in ['missing', 'null', 'empty', 'incomplete']):
+            return self._generate_missing_data_analysis(df)
+        
+        # Correlation questions
+        elif any(word in question_lower for word in ['correlation', 'relationship', 'related', 'associated']):
+            return self._generate_correlation_analysis(df)
+        
+        # Statistics questions
+        elif any(word in question_lower for word in ['statistics', 'stats', 'mean', 'average', 'median']):
+            return self._generate_statistics_analysis(df)
+        
+        # Visualization suggestions
+        elif any(word in question_lower for word in ['chart', 'plot', 'visualize', 'graph']):
+            return self._generate_visualization_suggestions(df)
+        
+        # Data quality questions
+        elif any(word in question_lower for word in ['quality', 'clean', 'issues', 'problems']):
+            return self._generate_data_quality_analysis(df)
+        
+        # Default response with basic info
+        else:
+            return self._generate_default_response(question, df)
+    
+    def _generate_data_overview(self, df: pd.DataFrame) -> str:
+        """Generate data overview response"""
+        numeric_cols = len(df.select_dtypes(include=['number']).columns)
+        categorical_cols = len(df.select_dtypes(include=['object']).columns)
+        
+        return f"""📊 **Data Overview**
+        
+**Dataset Summary:**
+• Shape: {df.shape[0]:,} rows × {df.shape[1]} columns
+• Numeric columns: {numeric_cols}
+• Categorical columns: {categorical_cols}
+• Total data points: {df.shape[0] * df.shape[1]:,}
+
+**Key Insights:**
+• The dataset contains {df.shape[0]:,} observations
+• Memory usage: ~{df.memory_usage().sum() / 1024:.1f} KB
+• Column diversity: {df.shape[1]} different variables to analyze
+
+💡 **Suggested next steps:** Explore correlations, check data quality, or create visualizations!
+        """
+    
+    def _generate_missing_data_analysis(self, df: pd.DataFrame) -> str:
+        """Generate missing data analysis response"""
+        missing = df.isnull().sum()
+        missing_cols = missing[missing > 0]
+        
+        if missing_cols.empty:
+            return """✅ **Missing Data Analysis**
+            
+**Great news!** Your dataset has no missing values. This indicates:
+• High data quality
+• Complete observations for all variables
+• Ready for analysis without imputation
+
+💡 **This makes your analysis more reliable and straightforward!**
+            """
+        else:
+            total_missing = missing_cols.sum()
+            missing_percentage = (total_missing / (df.shape[0] * df.shape[1])) * 100
+            
+            missing_info = "\n".join([f"• {col}: {count} missing ({count/len(df)*100:.1f}%)" 
+                                    for col, count in missing_cols.head(5).items()])
+            
+            return f"""⚠️ **Missing Data Analysis**
+            
+**Missing Data Found:**
+{missing_info}
+
+**Impact Assessment:**
+• Total missing values: {total_missing:,}
+• Percentage of dataset: {missing_percentage:.2f}%
+• Affected columns: {len(missing_cols)}
+
+💡 **Recommendations:**
+• Consider data imputation strategies
+• Analyze patterns in missing data
+• Evaluate if missing data is random or systematic
+            """
+    
+    def _generate_correlation_analysis(self, df: pd.DataFrame) -> str:
+        """Generate correlation analysis response"""
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        
+        if len(numeric_cols) < 2:
+            return """📊 **Correlation Analysis**
+            
+**Limited Analysis:** Your dataset has fewer than 2 numeric columns, so correlation analysis isn't applicable.
+
+💡 **Suggestions:**
+• Look at categorical relationships instead
+• Consider frequency distributions
+• Explore data patterns within individual variables
+            """
+        
+        # Calculate correlations
+        corr_matrix = df[numeric_cols].corr()
+        
+        # Find strong correlations
+        strong_corr = []
+        for i in range(len(corr_matrix.columns)):
+            for j in range(i+1, len(corr_matrix.columns)):
+                corr_val = corr_matrix.iloc[i, j]
+                if abs(corr_val) > 0.5:
+                    strength = "Strong" if abs(corr_val) > 0.7 else "Moderate"
+                    direction = "positive" if corr_val > 0 else "negative"
+                    strong_corr.append((corr_matrix.columns[i], corr_matrix.columns[j], 
+                                     corr_val, strength, direction))
+        
+        if strong_corr:
+            corr_info = "\n".join([f"• {pair[0]} ↔ {pair[1]}: {pair[2]:.3f} ({pair[3]} {pair[4]})"
+                                 for pair in strong_corr[:5]])
+            return f"""🔗 **Correlation Analysis**
+            
+**Strong Relationships Found:**
+{corr_info}
+
+**Analysis Summary:**
+• {len(strong_corr)} significant correlations detected
+• Analyzed {len(numeric_cols)} numeric variables
+• Correlation threshold: >0.5
+
+💡 **Insights:** These relationships could be key for predictive modeling or understanding data patterns!
+            """
+        else:
+            return f"""🔗 **Correlation Analysis**
+            
+**Analysis Results:**
+• Analyzed {len(numeric_cols)} numeric variables
+• No strong correlations (>0.5) detected
+• Variables appear relatively independent
+
+💡 **This suggests:**
+• Variables measure different aspects
+• Good for diverse analysis approaches
+• Less multicollinearity concerns
+            """
+    
+    def _generate_statistics_analysis(self, df: pd.DataFrame) -> str:
+        """Generate statistical analysis response"""
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        
+        if len(numeric_cols) == 0:
+            return """📊 **Statistical Analysis**
+            
+**No numeric columns found** for statistical analysis.
+
+💡 **Alternative approaches:**
+• Frequency distributions for categorical data
+• Mode analysis for text columns
+• Data type conversions if needed
+            """
+        
+        stats_summary = []
+        for col in numeric_cols[:5]:  # Limit to first 5 columns
+            data = df[col]
+            stats_summary.append(f"**{col}:**")
+            stats_summary.append(f"  • Mean: {data.mean():.2f}")
+            stats_summary.append(f"  • Median: {data.median():.2f}")
+            stats_summary.append(f"  • Std Dev: {data.std():.2f}")
+            stats_summary.append(f"  • Range: {data.min():.2f} to {data.max():.2f}")
+            stats_summary.append("")
+        
+        return f"""📊 **Statistical Analysis**
+        
+{chr(10).join(stats_summary)}
+        
+**Key Insights:**
+• {len(numeric_cols)} numeric variables analyzed
+• Statistical distributions vary across columns
+• Ready for advanced analytics
+
+💡 **Next steps:** Consider outlier detection, normalization, or predictive modeling!
+        """
+    
+    def _generate_visualization_suggestions(self, df: pd.DataFrame) -> str:
+        """Generate visualization suggestions"""
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        categorical_cols = df.select_dtypes(include=['object']).columns
+        
+        suggestions = []
+        
+        if len(numeric_cols) >= 2:
+            suggestions.append("• **Scatter Plot**: Explore relationships between numeric variables")
+            suggestions.append("• **Correlation Heatmap**: Visualize all correlations at once")
+        
+        if len(numeric_cols) >= 1:
+            suggestions.append("• **Histogram**: Show distribution of numeric variables")
+            suggestions.append("• **Box Plot**: Identify outliers and quartiles")
+        
+        if len(categorical_cols) >= 1:
+            suggestions.append("• **Bar Chart**: Compare categories and frequencies")
+            suggestions.append("• **Pie Chart**: Show proportions of categories")
+        
+        if len(numeric_cols) >= 1 and len(categorical_cols) >= 1:
+            suggestions.append("• **Grouped Charts**: Compare numeric values across categories")
+        
+        if not suggestions:
+            suggestions.append("• **Data Table**: Explore your data structure first")
+        
+        return f"""📈 **Visualization Suggestions**
+        
+**Recommended Charts for Your Data:**
+{chr(10).join(suggestions)}
+
+**Data Composition:**
+• Numeric columns: {len(numeric_cols)}
+• Categorical columns: {len(categorical_cols)}
+• Total observations: {len(df):,}
+
+💡 **Tip:** Start with simple charts and build complexity as you discover patterns!
+        """
+    
+    def _generate_data_quality_analysis(self, df: pd.DataFrame) -> str:
+        """Generate data quality analysis"""
+        quality_issues = []
+        quality_score = 100
+        
+        # Check for missing values
+        missing_count = df.isnull().sum().sum()
+        if missing_count > 0:
+            missing_pct = (missing_count / (df.shape[0] * df.shape[1])) * 100
+            quality_issues.append(f"• Missing values: {missing_count:,} ({missing_pct:.1f}% of data)")
+            quality_score -= min(missing_pct * 2, 30)
+        
+        # Check for duplicate rows
+        duplicate_count = df.duplicated().sum()
+        if duplicate_count > 0:
+            duplicate_pct = (duplicate_count / len(df)) * 100
+            quality_issues.append(f"• Duplicate rows: {duplicate_count} ({duplicate_pct:.1f}%)")
+            quality_score -= min(duplicate_pct * 1.5, 25)
+        
+        # Check for potential outliers in numeric columns
+        numeric_cols = df.select_dtypes(include=['number']).columns
+        outlier_cols = []
+        for col in numeric_cols:
+            Q1 = df[col].quantile(0.25)
+            Q3 = df[col].quantile(0.75)
+            IQR = Q3 - Q1
+            outliers = df[(df[col] < (Q1 - 1.5 * IQR)) | (df[col] > (Q3 + 1.5 * IQR))][col].count()
+            if outliers > len(df) * 0.05:  # More than 5% outliers
+                outlier_cols.append((col, outliers))
+        
+        if outlier_cols:
+            quality_issues.append(f"• Potential outliers detected in {len(outlier_cols)} columns")
+            quality_score -= len(outlier_cols) * 5
+        
+        quality_score = max(quality_score, 0)
+        
+        if not quality_issues:
+            return f"""✅ **Data Quality Assessment**
+            
+**Excellent Data Quality! Score: {quality_score:.0f}/100**
+
+**Quality Indicators:**
+• No missing values detected
+• No duplicate rows found
+• Outliers within acceptable ranges
+• Data ready for analysis
+
+💡 **Your data is clean and analysis-ready!**
+            """
+        else:
+            status_color = "🟢" if quality_score >= 80 else "🟡" if quality_score >= 60 else "🔴"
+            
+            return f"""{status_color} **Data Quality Assessment**
+            
+**Quality Score: {quality_score:.0f}/100**
+
+**Issues Detected:**
+{chr(10).join(quality_issues)}
+
+**Recommendations:**
+• Address missing values through imputation or removal
+• Consider duplicate row handling strategy
+• Investigate outliers for business significance
+
+💡 **Data cleaning will improve analysis reliability!**
+            """
+    
+    def _generate_default_response(self, question: str, df: pd.DataFrame) -> str:
+        """Generate default response with data context"""
+        return f"""🤖 **AI Assistant** (Demo Mode)
+        
+**Your Question:** "{question}"
+
+📊 **Dataset Context:**
+• Shape: {df.shape[0]:,} rows × {df.shape[1]} columns
+• Numeric columns: {len(df.select_dtypes(include=['number']).columns)}
+• Categorical columns: {len(df.select_dtypes(include=['object']).columns)}
+
+**I can help you with:**
+• Data overviews and summaries
+• Missing data analysis
+• Correlation insights
+• Statistical descriptions
+• Visualization suggestions
+• Data quality assessment
+
+💡 **Try asking:** "What's the data overview?" or "Are there any correlations?"
+
+⚙️ **Note:** Add OPENROUTER_API_KEY for advanced AI capabilities!
+        """
+
+# Create singleton instance
+ai_assistant = AIAssistant()
+
+def get_ai_response(question: str, df: pd.DataFrame) -> str:
+    """Main function to get AI response - can be called from main app"""
+    ai_assistant.set_dataset(df)
+    # Try LLM response first, fallback to basic response
+    return ai_assistant.get_llm_response(question, df)
+
+# Additional utility functions that can be expanded
+
+def suggest_chart_type(df: pd.DataFrame, x_col: str = None, y_col: str = None) -> Dict[str, Any]:
+    """Suggest the best chart type based on data types"""
+    suggestions = {
+        'recommended': 'scatter',
+        'alternatives': [],
+        'reasoning': ''
+    }
+    
+    if x_col and y_col:
+        x_dtype = df[x_col].dtype
+        y_dtype = df[y_col].dtype
+        
+        # Both numeric
+        if pd.api.types.is_numeric_dtype(x_dtype) and pd.api.types.is_numeric_dtype(y_dtype):
+            suggestions['recommended'] = 'scatter'
+            suggestions['alternatives'] = ['line', 'heatmap']
+            suggestions['reasoning'] = 'Both variables are numeric - scatter plot shows relationships best'
+        
+        # One categorical, one numeric
+        elif (pd.api.types.is_numeric_dtype(x_dtype) and pd.api.types.is_object_dtype(y_dtype)) or \
+             (pd.api.types.is_object_dtype(x_dtype) and pd.api.types.is_numeric_dtype(y_dtype)):
+            suggestions['recommended'] = 'bar'
+            suggestions['alternatives'] = ['box', 'violin']
+            suggestions['reasoning'] = 'Categorical vs numeric - bar chart shows comparisons clearly'
+        
+        # Both categorical
+        else:
+            suggestions['recommended'] = 'bar'
+            suggestions['alternatives'] = ['heatmap']
+            suggestions['reasoning'] = 'Both categorical - bar chart shows frequency distributions'
+    
+    elif x_col:
+        if pd.api.types.is_numeric_dtype(df[x_col].dtype):
+            suggestions['recommended'] = 'histogram'
+            suggestions['alternatives'] = ['box']
+            suggestions['reasoning'] = 'Single numeric variable - histogram shows distribution'
+        else:
+            suggestions['recommended'] = 'pie'
+            suggestions['alternatives'] = ['bar']
+            suggestions['reasoning'] = 'Single categorical variable - pie chart shows proportions'
+    
+    return suggestions
+
+def analyze_data_patterns(df: pd.DataFrame) -> Dict[str, Any]:
+    """Analyze patterns in the dataset"""
+    patterns = {
+        'trends': [],
+        'outliers': [],
+        'correlations': [],
+        'insights': []
+    }
+    
+    # This can be expanded with more sophisticated analysis
+    numeric_cols = df.select_dtypes(include=['number']).columns
+    
+    if len(numeric_cols) >= 2:
+        corr_matrix = df[numeric_cols].corr()
+        # Find strong correlations
+        for i in range(len(corr_matrix.columns)):
+            for j in range(i+1, len(corr_matrix.columns)):
+                corr_val = corr_matrix.iloc[i, j]
+                if abs(corr_val) > 0.7:
+                    patterns['correlations'].append({
+                        'variables': (corr_matrix.columns[i], corr_matrix.columns[j]),
+                        'correlation': corr_val,
+                        'strength': 'strong'
+                    })
+    
+    return patterns

ai_enhanced_app.py

@@ -0,0 +1,607 @@
+import os
+import base64
+import io
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from dash import Dash, html, dcc, Input, Output, State, callback_context
+import dash_bootstrap_components as dbc
+import numpy as np
+from scipy import stats
+import re
+
+# Initialize Dash app
+app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
+
+class AIVisualizationEngine:
+    def __init__(self, df):
+        self.df = df
+        self.numeric_cols = df.select_dtypes(include=['number']).columns.tolist()
+        self.categorical_cols = df.select_dtypes(include=['object']).columns.tolist()
+        self.datetime_cols = df.select_dtypes(include=['datetime64']).columns.tolist()
+    
+    def recommend_chart_type(self, x_col=None, y_col=None):
+        """AI-powered chart type recommendation"""
+        recommendations = []
+        
+        if x_col and y_col:
+            x_type = 'numeric' if x_col in self.numeric_cols else 'categorical'
+            y_type = 'numeric' if y_col in self.numeric_cols else 'categorical'
+            
+            if x_type == 'numeric' and y_type == 'numeric':
+                recommendations = [
+                    {'type': 'scatter', 'confidence': 0.9, 'reason': 'Both variables are numeric - scatter plot shows correlation'},
+                    {'type': 'line', 'confidence': 0.7, 'reason': 'Line chart good for trends if X is ordered'},
+                ]
+            elif x_type == 'categorical' and y_type == 'numeric':
+                recommendations = [
+                    {'type': 'bar', 'confidence': 0.9, 'reason': 'Categorical vs numeric - bar chart shows comparisons'},
+                    {'type': 'box', 'confidence': 0.8, 'reason': 'Box plot shows distribution across categories'},
+                ]
+            elif x_type == 'categorical' and y_type == 'categorical':
+                recommendations = [
+                    {'type': 'bar', 'confidence': 0.8, 'reason': 'Count relationships between categories'},
+                ]
+        elif x_col and not y_col:
+            if x_col in self.numeric_cols:
+                recommendations = [
+                    {'type': 'histogram', 'confidence': 0.9, 'reason': 'Single numeric variable - histogram shows distribution'},
+                    {'type': 'box', 'confidence': 0.7, 'reason': 'Box plot shows statistical summary'},
+                ]
+            else:
+                recommendations = [
+                    {'type': 'pie', 'confidence': 0.8, 'reason': 'Categorical variable - pie chart shows proportions'},
+                    {'type': 'bar', 'confidence': 0.9, 'reason': 'Bar chart shows category frequencies'},
+                ]
+        
+        return recommendations
+    
+    def detect_outliers(self, column):
+        """Detect outliers using IQR method"""
+        if column not in self.numeric_cols:
+            return []
+        
+        Q1 = self.df[column].quantile(0.25)
+        Q3 = self.df[column].quantile(0.75)
+        IQR = Q3 - Q1
+        lower_bound = Q1 - 1.5 * IQR
+        upper_bound = Q3 + 1.5 * IQR
+        
+        outliers = self.df[(self.df[column] < lower_bound) | (self.df[column] > upper_bound)]
+        return outliers.index.tolist()
+    
+    def generate_insights(self, x_col, y_col=None):
+        """Generate AI insights about the data"""
+        insights = []
+        
+        if x_col in self.numeric_cols:
+            mean_val = self.df[x_col].mean()
+            median_val = self.df[x_col].median()
+            std_val = self.df[x_col].std()
+            
+            insights.append(f"📊 {x_col}: Mean = {mean_val:.2f}, Median = {median_val:.2f}")
+            
+            if abs(mean_val - median_val) > std_val * 0.5:
+                insights.append(f"⚠️ {x_col} distribution appears skewed")
+            
+            outliers = self.detect_outliers(x_col)
+            if outliers:
+                insights.append(f"🎯 Found {len(outliers)} potential outliers in {x_col}")
+        
+        if y_col and x_col in self.numeric_cols and y_col in self.numeric_cols:
+            correlation = self.df[x_col].corr(self.df[y_col])
+            if abs(correlation) > 0.7:
+                strength = "strong" if abs(correlation) > 0.8 else "moderate"
+                direction = "positive" if correlation > 0 else "negative"
+                insights.append(f"🔗 {strength.title()} {direction} correlation ({correlation:.3f}) between {x_col} and {y_col}")
+            elif abs(correlation) < 0.3:
+                insights.append(f"📈 Weak correlation ({correlation:.3f}) between {x_col} and {y_col}")
+        
+        return insights
+    
+    def parse_natural_language_query(self, query):
+        """Simple NLP to parse visualization requests"""
+        query = query.lower().strip()
+        
+        # Extract chart types
+        chart_keywords = {
+            'scatter': ['scatter', 'correlation', 'relationship'],
+            'bar': ['bar', 'compare', 'comparison', 'by'],
+            'histogram': ['histogram', 'distribution', 'freq'],
+            'line': ['line', 'trend', 'over time', 'timeline'],
+            'box': ['box', 'quartile', 'median'],
+            'pie': ['pie', 'proportion', 'percentage'],
+            'heatmap': ['heatmap', 'correlation matrix']
+        }
+        
+        suggested_chart = None
+        for chart_type, keywords in chart_keywords.items():
+            if any(keyword in query for keyword in keywords):
+                suggested_chart = chart_type
+                break
+        
+        # Extract column names
+        mentioned_cols = []
+        for col in self.df.columns:
+            if col.lower() in query or col.lower().replace('_', ' ') in query:
+                mentioned_cols.append(col)
+        
+        return {
+            'chart_type': suggested_chart,
+            'columns': mentioned_cols,
+            'query': query
+        }
+    
+    def get_smart_color_scheme(self, chart_type, column=None):
+        """AI-powered color scheme selection"""
+        color_schemes = {
+            'scatter': 'Viridis',
+            'line': 'Blues',
+            'bar': 'Set3',
+            'histogram': 'Plasma',
+            'box': 'Set2',
+            'pie': 'Pastel',
+            'heatmap': 'RdBu_r'
+        }
+        return color_schemes.get(chart_type, 'Viridis')
+
+# App layout with AI features
+app.layout = dbc.Container([
+    dbc.Row([
+        dbc.Col([
+            html.H1("🤖 AI-Enhanced Data Dashboard", className="text-center mb-4"),
+            html.P("Upload data and let AI help you create intelligent visualizations!", 
+                   className="text-center text-muted"),
+            html.Hr(),
+        ], width=12)
+    ]),
+    
+    dbc.Row([
+        dbc.Col([
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("📁 Data Upload", className="card-title"),
+                    dcc.Upload(
+                        id='upload-data',
+                        children=html.Div([
+                            'Drag and Drop or ',
+                            html.A('Select Files')
+                        ]),
+                        style={
+                            'width': '100%',
+                            'height': '60px',
+                            'lineHeight': '60px',
+                            'borderWidth': '1px',
+                            'borderStyle': 'dashed',
+                            'borderRadius': '5px',
+                            'textAlign': 'center',
+                            'margin': '10px'
+                        },
+                        multiple=False,
+                        accept='.csv,.xlsx,.txt'
+                    ),
+                    
+                    html.Div(id='upload-status', className="mt-2"),
+                    html.Hr(),
+                    
+                    html.H4("🎯 AI Query Interface", className="card-title"),
+                    dbc.InputGroup([
+                        dbc.Input(
+                            id="ai-query",
+                            placeholder="Try: 'Show scatter plot of age vs salary' or 'Bar chart of departments'",
+                            type="text",
+                        ),
+                        dbc.Button(
+                            "🤖 AI Create", 
+                            id="ai-create-btn", 
+                            color="primary",
+                            n_clicks=0
+                        )
+                    ]),
+                    
+                    html.Div(id="ai-recommendations", className="mt-3"),
+                    html.Hr(),
+                    
+                    html.H4("📊 Quick Analytics", className="card-title"),
+                    dbc.ButtonGroup([
+                        dbc.Button("Summary Stats", id="stats-btn", size="sm"),
+                        dbc.Button("AI Insights", id="insights-btn", size="sm"),
+                        dbc.Button("Outliers", id="outliers-btn", size="sm"),
+                    ], className="w-100"),
+                    
+                    html.Div(id="quick-analytics", className="mt-3")
+                ])
+            ])
+        ], width=4),
+        
+        dbc.Col([
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("📈 AI-Enhanced Visualizations", className="card-title"),
+                    
+                    # Chart controls
+                    dbc.Row([
+                        dbc.Col([
+                            html.Label("Chart Type:", className="form-label"),
+                            dcc.Dropdown(
+                                id='chart-type',
+                                options=[
+                                    {'label': 'AI Recommend', 'value': 'ai_recommend'},
+                                    {'label': 'Scatter Plot', 'value': 'scatter'},
+                                    {'label': 'Line Chart', 'value': 'line'},
+                                    {'label': 'Bar Chart', 'value': 'bar'},
+                                    {'label': 'Histogram', 'value': 'histogram'},
+                                    {'label': 'Box Plot', 'value': 'box'},
+                                    {'label': 'Heatmap', 'value': 'heatmap'},
+                                    {'label': 'Pie Chart', 'value': 'pie'}
+                                ],
+                                value='ai_recommend',
+                                className="mb-2"
+                            )
+                        ], width=6),
+                        dbc.Col([
+                            html.Label("Color By:", className="form-label"),
+                            dcc.Dropdown(
+                                id='color-column',
+                                placeholder="AI will suggest colors",
+                                className="mb-2"
+                            )
+                        ], width=6)
+                    ]),
+                    
+                    dbc.Row([
+                        dbc.Col([
+                            html.Label("X-Axis:", className="form-label"),
+                            dcc.Dropdown(
+                                id='x-column',
+                                placeholder="Select X column"
+                            )
+                        ], width=6),
+                        dbc.Col([
+                            html.Label("Y-Axis:", className="form-label"),
+                            dcc.Dropdown(
+                                id='y-column',
+                                placeholder="Select Y column"
+                            )
+                        ], width=6)
+                    ], className="mb-3"),
+                    
+                    dcc.Graph(id='main-graph', style={'height': '500px'}),
+                    
+                    html.Div(id='ai-insights-display', className="mt-3")
+                ])
+            ]),
+            
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("🔍 Data Explorer", className="card-title"),
+                    html.Div(id='data-table')
+                ])
+            ], className="mt-3")
+        ], width=8)
+    ], className="mt-4"),
+    
+    # Store components
+    dcc.Store(id='stored-data'),
+    dcc.Store(id='ai-engine'),
+], fluid=True)
+
+def parse_contents(contents, filename):
+    """Parse uploaded file contents"""
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+    
+    try:
+        if 'csv' in filename:
+            df = pd.read_csv(io.StringIO(decoded.decode('utf-8')))
+        elif 'xls' in filename:
+            df = pd.read_excel(io.BytesIO(decoded))
+        else:
+            return None, "Unsupported file type"
+        
+        return df, None
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}"
+
+@app.callback(
+    [Output('stored-data', 'data'),
+     Output('upload-status', 'children'),
+     Output('data-table', 'children'),
+     Output('x-column', 'options'),
+     Output('y-column', 'options'),
+     Output('color-column', 'options'),
+     Output('x-column', 'value'),
+     Output('y-column', 'value')],
+    [Input('upload-data', 'contents')],
+    [State('upload-data', 'filename')]
+)
+def update_data(contents, filename):
+    """Update data when file is uploaded"""
+    if contents is None:
+        return None, "", "", [], [], [], None, None
+    
+    df, error = parse_contents(contents, filename)
+    
+    if error:
+        return None, dbc.Alert(error, color="danger"), "", [], [], [], None, None
+    
+    # Create data table preview
+    table = dbc.Table.from_dataframe(
+        df.head(10), 
+        striped=True, 
+        bordered=True, 
+        hover=True, 
+        size='sm'
+    )
+    
+    # AI analysis of dataset
+    ai_engine = AIVisualizationEngine(df)
+    
+    success_msg = dbc.Alert([
+        html.H6(f"✅ File uploaded successfully! 🤖 AI Ready"),
+        html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+        html.P(f"📊 Numeric: {len(ai_engine.numeric_cols)}, 📝 Categorical: {len(ai_engine.categorical_cols)}")
+    ], color="success")
+    
+    # Create column options for dropdowns
+    all_columns = [{'label': col, 'value': col} for col in df.columns]
+    
+    # AI recommends default columns
+    if ai_engine.numeric_cols:
+        default_x = ai_engine.numeric_cols[0]
+        default_y = ai_engine.numeric_cols[1] if len(ai_engine.numeric_cols) > 1 else None
+    else:
+        default_x = all_columns[0]['value'] if all_columns else None
+        default_y = all_columns[1]['value'] if len(all_columns) > 1 else None
+    
+    return df.to_dict('records'), success_msg, table, all_columns, all_columns, all_columns, default_x, default_y
+
+@app.callback(
+    [Output('chart-type', 'value'),
+     Output('ai-recommendations', 'children')],
+    [Input('ai-create-btn', 'n_clicks')],
+    [State('ai-query', 'value'),
+     State('stored-data', 'data')]
+)
+def handle_ai_query(n_clicks, query, data):
+    """Handle AI natural language queries"""
+    if not n_clicks or not query or not data:
+        return 'ai_recommend', ""
+    
+    df = pd.DataFrame(data)
+    ai_engine = AIVisualizationEngine(df)
+    
+    # Parse the natural language query
+    parsed = ai_engine.parse_natural_language_query(query)
+    
+    recommendations = []
+    if parsed['chart_type']:
+        recommendations.append(f"🎯 Suggested chart type: **{parsed['chart_type'].title()}**")
+    
+    if parsed['columns']:
+        recommendations.append(f"📊 Detected columns: {', '.join(parsed['columns'])}")
+    
+    if not recommendations:
+        recommendations.append("🤖 Try queries like: 'scatter age salary', 'bar chart departments', 'histogram of scores'")
+    
+    return parsed['chart_type'] or 'ai_recommend', dbc.Alert(recommendations, color="info")
+
+@app.callback(
+    Output('quick-analytics', 'children'),
+    [Input('stats-btn', 'n_clicks'),
+     Input('insights-btn', 'n_clicks'),
+     Input('outliers-btn', 'n_clicks')],
+    [State('stored-data', 'data'),
+     State('x-column', 'value'),
+     State('y-column', 'value')]
+)
+def quick_analytics(stats_clicks, insights_clicks, outliers_clicks, data, x_col, y_col):
+    """Handle quick analytics buttons with AI insights"""
+    if not data:
+        return ""
+    
+    df = pd.DataFrame(data)
+    ai_engine = AIVisualizationEngine(df)
+    ctx = callback_context
+    
+    if not ctx.triggered:
+        return ""
+    
+    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
+    
+    if button_id == 'stats-btn':
+        stats = df.describe()
+        return dbc.Alert([
+            html.H6("📊 Summary Statistics"),
+            dbc.Table.from_dataframe(stats.reset_index(), size='sm')
+        ], color="light")
+    
+    elif button_id == 'insights-btn':
+        if x_col:
+            insights = ai_engine.generate_insights(x_col, y_col)
+            return dbc.Alert([
+                html.H6("🤖 AI Insights"),
+                html.Ul([html.Li(insight) for insight in insights])
+            ], color="info")
+        return dbc.Alert("Select columns to get AI insights", color="warning")
+    
+    elif button_id == 'outliers-btn':
+        if x_col and x_col in ai_engine.numeric_cols:
+            outliers = ai_engine.detect_outliers(x_col)
+            if outliers:
+                outlier_data = df.loc[outliers, [x_col]]
+                return dbc.Alert([
+                    html.H6(f"🎯 Outliers in {x_col}"),
+                    dbc.Table.from_dataframe(outlier_data.reset_index(), size='sm')
+                ], color="warning")
+            return dbc.Alert(f"✅ No outliers detected in {x_col}", color="success")
+        return dbc.Alert("Select a numeric column to detect outliers", color="warning")
+    
+    return ""
+
+@app.callback(
+    [Output('main-graph', 'figure'),
+     Output('ai-insights-display', 'children')],
+    [Input('stored-data', 'data'),
+     Input('chart-type', 'value'),
+     Input('x-column', 'value'),
+     Input('y-column', 'value'),
+     Input('color-column', 'value')]
+)
+def update_main_graph(data, chart_type, x_col, y_col, color_col):
+    """Update visualization with AI enhancements"""
+    if not data:
+        fig = go.Figure()
+        fig.add_annotation(text="Upload data to see AI-powered visualizations", 
+                         x=0.5, y=0.5, showarrow=False, 
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig, ""
+    
+    df = pd.DataFrame(data)
+    ai_engine = AIVisualizationEngine(df)
+    
+    # AI recommendation system
+    if chart_type == 'ai_recommend' and x_col:
+        recommendations = ai_engine.recommend_chart_type(x_col, y_col)
+        if recommendations:
+            chart_type = recommendations[0]['type']
+    
+    # Handle cases where columns aren't selected yet
+    if not x_col and not y_col:
+        fig = go.Figure()
+        fig.add_annotation(text="Select columns or use AI Query to create visualization", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig, ""
+    
+    insights_display = ""
+    
+    try:
+        # Get AI-powered color scheme
+        color_scheme = ai_engine.get_smart_color_scheme(chart_type, color_col)
+        
+        # Create visualization based on chart type
+        if chart_type == 'scatter':
+            if x_col and y_col:
+                fig = px.scatter(df, x=x_col, y=y_col, color=color_col,
+                               title=f"🤖 AI Scatter Plot: {y_col} vs {x_col}",
+                               color_continuous_scale=color_scheme)
+                # Add AI insights
+                insights = ai_engine.generate_insights(x_col, y_col)
+                insights_display = dbc.Alert([
+                    html.H6("🤖 AI Insights"),
+                    html.Ul([html.Li(insight) for insight in insights])
+                ], color="info")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for scatter plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'line':
+            if x_col and y_col:
+                fig = px.line(df, x=x_col, y=y_col, color=color_col,
+                             title=f"🤖 AI Line Chart: {y_col} vs {x_col}",
+                             color_discrete_sequence=px.colors.qualitative.Set3)
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for line chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'bar':
+            if x_col and y_col:
+                fig = px.bar(df, x=x_col, y=y_col, color=color_col,
+                           title=f"🤖 AI Bar Chart: {y_col} by {x_col}",
+                           color_discrete_sequence=px.colors.qualitative.Set3)
+            elif x_col:
+                fig = px.bar(df[x_col].value_counts().reset_index(), 
+                           x='index', y=x_col,
+                           title=f"🤖 AI Value Counts: {x_col}",
+                           color_discrete_sequence=px.colors.qualitative.Set3)
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select at least X column for bar chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'histogram':
+            if x_col:
+                fig = px.histogram(df, x=x_col, color=color_col,
+                                 title=f"🤖 AI Histogram: {x_col}",
+                                 color_discrete_sequence=px.colors.qualitative.Pastel)
+                # Add statistical annotations
+                mean_val = df[x_col].mean() if x_col in ai_engine.numeric_cols else None
+                if mean_val:
+                    fig.add_vline(x=mean_val, line_dash="dash", line_color="red",
+                                annotation_text=f"Mean: {mean_val:.2f}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for histogram", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'box':
+            if y_col:
+                fig = px.box(df, x=color_col, y=y_col,
+                           title=f"🤖 AI Box Plot: {y_col}" + (f" by {color_col}" if color_col else ""),
+                           color_discrete_sequence=px.colors.qualitative.Set2)
+            elif x_col:
+                fig = px.box(df, y=x_col,
+                           title=f"🤖 AI Box Plot: {x_col}",
+                           color_discrete_sequence=px.colors.qualitative.Set2)
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select a column for box plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'heatmap':
+            numeric_cols = df.select_dtypes(include=['number']).columns
+            if len(numeric_cols) > 1:
+                corr_matrix = df[numeric_cols].corr()
+                fig = px.imshow(corr_matrix, 
+                              text_auto=True, 
+                              aspect="auto",
+                              title="🤖 AI Correlation Heatmap",
+                              color_continuous_scale='RdBu_r')
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Need at least 2 numeric columns for heatmap", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'pie':
+            if x_col:
+                value_counts = df[x_col].value_counts()
+                fig = px.pie(values=value_counts.values, 
+                           names=value_counts.index,
+                           title=f"🤖 AI Pie Chart: {x_col}",
+                           color_discrete_sequence=px.colors.qualitative.Pastel)
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for pie chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        else:
+            fig = go.Figure()
+            fig.add_annotation(text="🤖 AI is analyzing... Select chart type or use AI Query", 
+                             x=0.5, y=0.5, showarrow=False)
+        
+        # Apply AI styling enhancements
+        fig.update_layout(
+            template="plotly_white", 
+            height=500,
+            font=dict(size=12),
+            title_font_size=16,
+        )
+        
+        return fig, insights_display
+        
+    except Exception as e:
+        fig = go.Figure()
+        fig.add_annotation(text=f"AI Error: {str(e)}", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(color="red"))
+        fig.update_layout(template="plotly_white")
+        return fig, ""
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=8051, debug=True)

app1.py

@@ -0,0 +1,842 @@
+import os
+import base64
+import io
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from dash import Dash, html, dcc, Input, Output, State, callback_context
+import dash_bootstrap_components as dbc
+from typing import Optional
+from dotenv import load_dotenv
+from pydantic import Field, SecretStr
+import numpy as np
+
+# Langchain imports - simplified without embeddings
+from langchain_community.vectorstores import FAISS
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain.schema import Document
+from langchain_core.prompts import PromptTemplate
+
+# Load environment variables
+load_dotenv()
+
+# Simplified - no OpenRouter for now
+AI_AVAILABLE = False
+openrouter_model = None
+
+# Initialize Dash app
+app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
+
+# Global variables
+vector_store = None
+
+# Built-in datasets
+def create_builtin_datasets():
+    """Create built-in sample datasets"""
+    datasets = {}
+    
+    # Gapminder dataset
+    np.random.seed(42)
+    countries = ['USA', 'China', 'India', 'Germany', 'UK', 'France', 'Japan', 'Brazil', 'Canada', 'Australia']
+    years = list(range(2000, 2021))
+    gapminder_data = []
+    for country in countries:
+        base_gdp = np.random.uniform(20000, 80000)
+        base_life_exp = np.random.uniform(70, 85)
+        base_pop = np.random.uniform(10000000, 100000000)
+        for year in years:
+            gapminder_data.append({
+                'country': country,
+                'year': year,
+                'gdpPercap': base_gdp * (1 + np.random.uniform(-0.1, 0.15)) * ((year-2000)*0.02 + 1),
+                'lifeExp': base_life_exp + np.random.uniform(-2, 3) + (year-2000)*0.1,
+                'pop': base_pop * (1.01 + np.random.uniform(-0.005, 0.015))**(year-2000),
+                'continent': 'Asia' if country in ['China', 'India', 'Japan'] else 'Europe' if country in ['Germany', 'UK', 'France'] else 'Americas' if country in ['USA', 'Brazil', 'Canada'] else 'Oceania'
+            })
+    datasets['Gapminder'] = pd.DataFrame(gapminder_data)
+    
+    # Iris dataset
+    from sklearn.datasets import load_iris
+    try:
+        iris = load_iris()
+        datasets['Iris'] = pd.DataFrame(iris.data, columns=iris.feature_names)
+        datasets['Iris']['species'] = [iris.target_names[i] for i in iris.target]
+    except ImportError:
+        # Fallback if sklearn not available
+        iris_data = {
+            'sepal_length': np.random.normal(5.8, 0.8, 150),
+            'sepal_width': np.random.normal(3.0, 0.4, 150),
+            'petal_length': np.random.normal(3.8, 1.8, 150),
+            'petal_width': np.random.normal(1.2, 0.8, 150),
+            'species': ['setosa']*50 + ['versicolor']*50 + ['virginica']*50
+        }
+        datasets['Iris'] = pd.DataFrame(iris_data)
+    
+    # Tips dataset
+    tips_data = {
+        'total_bill': np.random.uniform(10, 50, 200),
+        'tip': np.random.uniform(1, 10, 200),
+        'sex': np.random.choice(['Male', 'Female'], 200),
+        'smoker': np.random.choice(['Yes', 'No'], 200),
+        'day': np.random.choice(['Thur', 'Fri', 'Sat', 'Sun'], 200),
+        'time': np.random.choice(['Lunch', 'Dinner'], 200),
+        'size': np.random.choice([1, 2, 3, 4, 5, 6], 200)
+    }
+    datasets['Tips'] = pd.DataFrame(tips_data)
+    
+    # Stock Data
+    dates = pd.date_range('2020-01-01', '2023-12-31', freq='D')
+    stock_price = 100
+    stock_data = []
+    for date in dates:
+        daily_return = np.random.normal(0.001, 0.02)
+        stock_price *= (1 + daily_return)
+        stock_data.append({
+            'date': date,
+            'price': stock_price,
+            'volume': np.random.randint(1000000, 5000000),
+            'high': stock_price * (1 + abs(np.random.normal(0, 0.01))),
+            'low': stock_price * (1 - abs(np.random.normal(0, 0.01))),
+            'open': stock_price * (1 + np.random.normal(0, 0.005))
+        })
+    datasets['Stock Data'] = pd.DataFrame(stock_data)
+    
+    # Wind Data
+    hours = list(range(24))
+    wind_data = []
+    for month in range(1, 13):
+        for day in range(1, 29):
+            for hour in hours:
+                wind_data.append({
+                    'month': month,
+                    'day': day,
+                    'hour': hour,
+                    'wind_speed': abs(np.random.normal(15, 8)) + 5*np.sin(hour/24*2*np.pi),
+                    'temperature': np.random.normal(20, 15) + 10*np.cos(month/12*2*np.pi),
+                    'humidity': np.random.uniform(30, 90),
+                    'pressure': np.random.normal(1013, 20)
+                })
+    datasets['Wind Data'] = pd.DataFrame(wind_data)
+    
+    return datasets
+
+# Initialize built-in datasets
+builtin_datasets = create_builtin_datasets()
+
+# App layout
+app.layout = dbc.Container([
+    dbc.Row([
+        dbc.Col([
+            html.H1("🤖 AI-Powered Data Analytics", className="text-center mb-4"),
+            html.P("Upload data, ask questions, and get AI-powered insights!", 
+                   className="text-center text-muted"),
+            html.Hr(),
+        ], width=12)
+    ]),
+    
+    # Tabbed interface
+    dbc.Tabs([
+        # Tab 1: Dataset Management
+        dbc.Tab(label="📁 Dataset Management", tab_id="dataset-management", children=[
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            html.H4("Load Built-in Dataset", className="card-title"),
+                            dcc.Dropdown(
+                                id="builtin-choice",
+                                options=[
+                                    {"label": "Gapminder", "value": "Gapminder"},
+                                    {"label": "Iris", "value": "Iris"},
+                                    {"label": "Tips", "value": "Tips"},
+                                    {"label": "Stock Data", "value": "Stock Data"},
+                                    {"label": "Wind Data", "value": "Wind Data"}
+                                ],
+                                value="Gapminder",
+                                className="mb-2"
+                            ),
+                            dbc.Button("Load Dataset", id="load-builtin-btn", color="primary", className="mb-3"),
+                            
+                            html.Hr(),
+                            html.H4("Upload Custom Dataset", className="card-title"),
+                            dcc.Upload(
+                                id='file-upload',
+                                children=html.Div([
+                                    'Drag and Drop or ',
+                                    html.A('Select CSV/Excel Files')
+                                ]),
+                                style={
+                                    'width': '100%',
+                                    'height': '60px',
+                                    'lineHeight': '60px',
+                                    'borderWidth': '1px',
+                                    'borderStyle': 'dashed',
+                                    'borderRadius': '5px',
+                                    'textAlign': 'center',
+                                    'margin': '10px'
+                                },
+                                multiple=False,
+                                accept='.csv,.xlsx,.xls'
+                            ),
+                            
+                            dbc.Input(
+                                id="custom-name",
+                                placeholder="Dataset Name (optional)",
+                                type="text",
+                                className="mb-2"
+                            ),
+                            dbc.Button("Upload", id="upload-btn", color="primary", className="mb-3"),
+                            
+                            html.Hr(),
+                            html.H4("Active Datasets", className="card-title"),
+                            dcc.Dropdown(
+                                id="dataset-selector",
+                                options=[{"label": "Gapminder", "value": "Gapminder"}],
+                                value="Gapminder",
+                                className="mb-2"
+                            ),
+                            
+                            html.Hr(),
+                            html.Div(id="status-msg", children=[
+                                dbc.Alert("Ready to load data", color="info")
+                            ]),
+                            html.Div(id="data-info")
+                        ])
+                    ])
+                ], width=4),
+                
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            html.H4("Data Preview (First 10 rows)", className="card-title"),
+                            html.Div(id="data-preview", className="mb-4"),
+                            html.H4("Quick Analytics", className="card-title"),
+                            html.Div(id="auto-analytics")
+                        ])
+                    ])
+                ], width=8)
+            ], className="mt-4")
+        ]),
+        
+        # Tab 2: AI Assistant
+        dbc.Tab(label="🤖 AI Assistant", tab_id="ai-assistant", children=[
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            html.H4("🤖 AI Assistant", className="card-title"),
+                            html.Div(id="ai-dataset-info", className="mb-3", children=[
+                                dbc.Alert("No dataset loaded. Please load a dataset in the Dataset Management tab first.", 
+                                         color="warning", className="mb-3")
+                            ]),
+                            dbc.InputGroup([
+                                dbc.Input(
+                                    id="ai-question",
+                                    placeholder="Ask questions about your data...",
+                                    type="text",
+                                    style={"fontSize": "14px"}
+                                ),
+                                dbc.Button(
+                                    "Ask AI", 
+                                    id="ask-button", 
+                                    color="primary",
+                                    n_clicks=0
+                                )
+                            ]),
+                            
+                            html.Div(id="ai-response", className="mt-3")
+                        ])
+                    ])
+                ], width=12)
+            ], className="mt-4")
+        ]),
+        
+        # Tab 3: Visualizations
+        dbc.Tab(label="📈 Visualizations", tab_id="visualizations", children=[
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            html.H4("📈 Visualizations", className="card-title"),
+                            
+                            # Chart controls
+                            dbc.Row([
+                                dbc.Col([
+                                    html.Label("Chart Type:", className="form-label"),
+                                    dcc.Dropdown(
+                                        id='chart-type',
+                                        options=[
+                                            {'label': 'Scatter Plot', 'value': 'scatter'},
+                                            {'label': 'Line Chart', 'value': 'line'},
+                                            {'label': 'Bar Chart', 'value': 'bar'},
+                                            {'label': 'Histogram', 'value': 'histogram'},
+                                            {'label': 'Box Plot', 'value': 'box'},
+                                            {'label': 'Heatmap', 'value': 'heatmap'},
+                                            {'label': 'Pie Chart', 'value': 'pie'}
+                                        ],
+                                        value='scatter',
+                                        className="mb-2"
+                                    )
+                                ], width=6),
+                                dbc.Col([
+                                    html.Label("Color By:", className="form-label"),
+                                    dcc.Dropdown(
+                                        id='color-column',
+                                        placeholder="Select column (optional)",
+                                        className="mb-2"
+                                    )
+                                ], width=6)
+                            ]),
+                            
+                            dbc.Row([
+                                dbc.Col([
+                                    html.Label("X-Axis:", className="form-label"),
+                                    dcc.Dropdown(
+                                        id='x-column',
+                                        placeholder="Select X column"
+                                    )
+                                ], width=6),
+                                dbc.Col([
+                                    html.Label("Y-Axis:", className="form-label"),
+                                    dcc.Dropdown(
+                                        id='y-column',
+                                        placeholder="Select Y column"
+                                    )
+                                ], width=6)
+                            ], className="mb-3"),
+                            
+                            dcc.Graph(id='main-graph', style={'height': '500px'}),
+                        ])
+                    ])
+                ], width=12)
+            ], className="mt-4")
+        ]),
+        
+        # Tab 4: Data Explorer
+        dbc.Tab(label="🔍 Data Explorer", tab_id="data-explorer", children=[
+            dbc.Row([
+                dbc.Col([
+                    dbc.Card([
+                        dbc.CardBody([
+                            html.H4("🔍 Data Explorer", className="card-title"),
+                            html.Div(id='data-table')
+                        ])
+                    ])
+                ], width=12)
+            ], className="mt-4")
+        ])
+    ], id="main-tabs", active_tab="dataset-management"),
+    
+    # Store components
+    dcc.Store(id='stored-data'),
+    dcc.Store(id='data-context'),
+    dcc.Store(id='dataset-registry', data={"Gapminder": "builtin"}),
+    dcc.Store(id='current-dataset-name', data="Gapminder")
+], fluid=True)
+
+def create_vector_store(df):
+    """Simplified - just return True for now"""
+    return True
+
+# Import AI assistant module
+from ai_assistant import get_ai_response
+
+def create_auto_analytics(df):
+    """Create automatic analytics display"""
+    analytics_components = []
+    
+    # Summary Statistics
+    numeric_cols = df.select_dtypes(include=['number']).columns
+    if len(numeric_cols) > 0:
+        stats = df[numeric_cols].describe()
+        analytics_components.extend([
+            html.H6("📊 Summary Statistics", className="mt-2"),
+            dbc.Table.from_dataframe(
+                stats.reset_index().round(2), 
+                size='sm', 
+                striped=True, 
+                hover=True
+            )
+        ])
+    
+    # Missing Data Analysis
+    missing_data = df.isnull().sum()
+    missing_data = missing_data[missing_data > 0]
+    if not missing_data.empty:
+        analytics_components.extend([
+            html.H6("⚠️ Missing Data", className="mt-3"),
+            dbc.Alert([
+                html.Pre(missing_data.to_string())
+            ], color="warning")
+        ])
+    else:
+        analytics_components.extend([
+            html.H6("✅ Data Quality", className="mt-3"),
+            dbc.Alert("No missing values found!", color="success")
+        ])
+    
+    # Data Types Analysis
+    dtype_info = df.dtypes.value_counts()
+    analytics_components.extend([
+        html.H6("🔍 Data Types", className="mt-3"),
+        dbc.Alert([
+            html.P(f"📈 Numeric columns: {len(df.select_dtypes(include=['number']).columns)}"),
+            html.P(f"📝 Text columns: {len(df.select_dtypes(include=['object']).columns)}"),
+            html.P(f"📅 DateTime columns: {len(df.select_dtypes(include=['datetime64']).columns)}"),
+            html.P(f"🔢 Boolean columns: {len(df.select_dtypes(include=['bool']).columns)}")
+        ], color="light")
+    ])
+    
+    # Correlation Analysis for numeric columns
+    if len(numeric_cols) > 1:
+        corr_matrix = df[numeric_cols].corr()
+        # Find highest correlations
+        corr_pairs = []
+        for i in range(len(corr_matrix.columns)):
+            for j in range(i+1, len(corr_matrix.columns)):
+                corr_val = corr_matrix.iloc[i, j]
+                if abs(corr_val) > 0.5:  # Only show strong correlations
+                    corr_pairs.append((corr_matrix.columns[i], corr_matrix.columns[j], corr_val))
+        
+        if corr_pairs:
+            analytics_components.extend([
+                html.H6("🔗 Strong Correlations (>0.5)", className="mt-3"),
+                dbc.Alert([
+                    html.P(f"{pair[0]} ↔ {pair[1]}: {pair[2]:.3f}") for pair in corr_pairs[:5]  # Show top 5
+                ], color="info")
+            ])
+    
+    return analytics_components
+
+def parse_contents(contents, filename):
+    """Parse uploaded file contents"""
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+    
+    try:
+        if 'csv' in filename:
+            df = pd.read_csv(io.StringIO(decoded.decode('utf-8')))
+        elif 'xls' in filename:
+            df = pd.read_excel(io.BytesIO(decoded))
+        else:
+            return None, "Unsupported file type"
+        
+        return df, None
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}"
+
+# Dataset management callbacks
+@app.callback(
+    [Output('stored-data', 'data'),
+     Output('status-msg', 'children'),
+     Output('data-preview', 'children'),
+     Output('data-info', 'children'),
+     Output('auto-analytics', 'children'),
+     Output('x-column', 'options'),
+     Output('y-column', 'options'),
+     Output('color-column', 'options'),
+     Output('x-column', 'value'),
+     Output('y-column', 'value'),
+     Output('dataset-registry', 'data'),
+     Output('dataset-selector', 'options'),
+     Output('current-dataset-name', 'data')],
+    [Input('load-builtin-btn', 'n_clicks'),
+     Input('file-upload', 'contents'),
+     Input('dataset-selector', 'value')],
+    [State('builtin-choice', 'value'),
+     State('file-upload', 'filename'),
+     State('custom-name', 'value'),
+     State('dataset-registry', 'data')]
+)
+def manage_datasets(builtin_clicks, file_contents, selected_dataset, builtin_choice, filename, custom_name, registry):
+    """Handle dataset loading and switching"""
+    ctx = callback_context
+    
+    # Initialize defaults
+    registry = registry or {"Gapminder": "builtin"}
+    
+    if not ctx.triggered:
+        # Initial load - load Gapminder dataset
+        df = builtin_datasets["Gapminder"]
+        dataset_name = "Gapminder"
+        
+        # Create vector store for AI
+        vector_success = create_vector_store(df)
+        
+        # Create data table preview
+        table = dbc.Table.from_dataframe(
+            df.head(10), 
+            striped=True, 
+            bordered=True, 
+            hover=True, 
+            size='sm'
+        )
+        
+        ai_status = "🤖 AI Ready" if vector_success else "⚠️ AI Limited"
+        status_msg = dbc.Alert(f"✅ Gapminder dataset loaded! {ai_status}", color="success")
+        
+        data_info = dbc.Alert([
+            html.H6("Dataset Information:"),
+            html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+            html.P(f"Columns: {', '.join(df.columns.tolist())}"),
+            html.P(f"Data types: {len(df.select_dtypes(include=['number']).columns)} numeric, {len(df.select_dtypes(include=['object']).columns)} categorical")
+        ], color="light")
+        
+        # Create automatic analytics
+        auto_analytics = create_auto_analytics(df)
+        
+        # Create column options for dropdowns
+        all_columns = [{'label': col, 'value': col} for col in df.columns]
+        numeric_columns = [{'label': col, 'value': col} for col in df.select_dtypes(include=['number']).columns]
+        
+        # Set default values - prefer numeric columns for x and y
+        default_x = numeric_columns[0]['value'] if numeric_columns else all_columns[0]['value'] if all_columns else None
+        default_y = numeric_columns[1]['value'] if len(numeric_columns) > 1 else (numeric_columns[0]['value'] if numeric_columns else (all_columns[1]['value'] if len(all_columns) > 1 else None))
+        
+        selector_options = [{"label": name, "value": name} for name in registry.keys()]
+        
+        return df.to_dict('records'), status_msg, table, data_info, auto_analytics, all_columns, all_columns, all_columns, default_x, default_y, registry, selector_options, dataset_name
+    
+    trigger_id = ctx.triggered[0]['prop_id'].split('.')[0]
+    
+    if trigger_id == 'load-builtin-btn' and builtin_clicks:
+        # Load built-in dataset
+        if builtin_choice in builtin_datasets:
+            df = builtin_datasets[builtin_choice]
+            registry[builtin_choice] = "builtin"
+            
+            # Create vector store for AI
+            vector_success = create_vector_store(df)
+            
+            # Create data table preview
+            table = dbc.Table.from_dataframe(
+                df.head(10), 
+                striped=True, 
+                bordered=True, 
+                hover=True, 
+                size='sm'
+            )
+            
+            ai_status = "🤖 AI Ready" if vector_success else "⚠️ AI Limited"
+            status_msg = dbc.Alert(f"✅ {builtin_choice} dataset loaded! {ai_status}", color="success")
+            
+            data_info = dbc.Alert([
+                html.H6(f"{builtin_choice} Dataset Information:"),
+                html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+                html.P(f"Columns: {', '.join(df.columns.tolist())}"),
+                html.P(f"Data types: {len(df.select_dtypes(include=['number']).columns)} numeric, {len(df.select_dtypes(include=['object']).columns)} categorical")
+            ], color="light")
+            
+            # Create automatic analytics
+            auto_analytics = create_auto_analytics(df)
+            
+            # Create column options for dropdowns
+            all_columns = [{'label': col, 'value': col} for col in df.columns]
+            numeric_columns = [{'label': col, 'value': col} for col in df.select_dtypes(include=['number']).columns]
+            
+            # Set default values - prefer numeric columns for x and y
+            default_x = numeric_columns[0]['value'] if numeric_columns else all_columns[0]['value'] if all_columns else None
+            default_y = numeric_columns[1]['value'] if len(numeric_columns) > 1 else (numeric_columns[0]['value'] if numeric_columns else (all_columns[1]['value'] if len(all_columns) > 1 else None))
+            
+            selector_options = [{"label": name, "value": name} for name in registry.keys()]
+            
+            return df.to_dict('records'), status_msg, table, data_info, auto_analytics, all_columns, all_columns, all_columns, default_x, default_y, registry, selector_options, builtin_choice
+    
+    elif trigger_id == 'file-upload' and file_contents:
+        # Upload custom dataset
+        df, error = parse_contents(file_contents, filename)
+        
+        if error:
+            status_msg = dbc.Alert(error, color="danger")
+            selector_options = [{"label": name, "value": name} for name in registry.keys()]
+            return None, status_msg, "", "", "", [], [], [], None, None, registry, selector_options, None
+        
+        # Determine dataset name
+        dataset_name = custom_name if custom_name else filename.split('.')[0]
+        registry[dataset_name] = "custom"
+        
+        # Create vector store for AI
+        vector_success = create_vector_store(df)
+        
+        # Create data table preview
+        table = dbc.Table.from_dataframe(
+            df.head(10), 
+            striped=True, 
+            bordered=True, 
+            hover=True, 
+            size='sm'
+        )
+        
+        ai_status = "🤖 AI Ready" if vector_success else "⚠️ AI Limited"
+        status_msg = dbc.Alert(f"✅ {dataset_name} uploaded successfully! {ai_status}", color="success")
+        
+        data_info = dbc.Alert([
+            html.H6(f"{dataset_name} Dataset Information:"),
+            html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+            html.P(f"Columns: {', '.join(df.columns.tolist())}"),
+            html.P(f"Data types: {len(df.select_dtypes(include=['number']).columns)} numeric, {len(df.select_dtypes(include=['object']).columns)} categorical")
+        ], color="light")
+        
+        # Create automatic analytics
+        auto_analytics = create_auto_analytics(df)
+        
+        # Create column options for dropdowns
+        all_columns = [{'label': col, 'value': col} for col in df.columns]
+        numeric_columns = [{'label': col, 'value': col} for col in df.select_dtypes(include=['number']).columns]
+        
+        # Set default values - prefer numeric columns for x and y
+        default_x = numeric_columns[0]['value'] if numeric_columns else all_columns[0]['value'] if all_columns else None
+        default_y = numeric_columns[1]['value'] if len(numeric_columns) > 1 else (numeric_columns[0]['value'] if numeric_columns else (all_columns[1]['value'] if len(all_columns) > 1 else None))
+        
+        selector_options = [{"label": name, "value": name} for name in registry.keys()]
+        
+        return df.to_dict('records'), status_msg, table, data_info, auto_analytics, all_columns, all_columns, all_columns, default_x, default_y, registry, selector_options, dataset_name
+    
+    elif trigger_id == 'dataset-selector' and selected_dataset:
+        # Switch between datasets
+        if selected_dataset in registry:
+            if registry[selected_dataset] == "builtin" and selected_dataset in builtin_datasets:
+                df = builtin_datasets[selected_dataset]
+            else:
+                # For custom datasets, we would need to store them persistently
+                # For now, just reload builtin if available
+                if selected_dataset in builtin_datasets:
+                    df = builtin_datasets[selected_dataset]
+                else:
+                    # Fallback to Gapminder if dataset not found
+                    df = builtin_datasets["Gapminder"]
+                    selected_dataset = "Gapminder"
+            
+            # Create vector store for AI
+            vector_success = create_vector_store(df)
+            
+            # Create data table preview
+            table = dbc.Table.from_dataframe(
+                df.head(10), 
+                striped=True, 
+                bordered=True, 
+                hover=True, 
+                size='sm'
+            )
+            
+            ai_status = "🤖 AI Ready" if vector_success else "⚠️ AI Limited"
+            status_msg = dbc.Alert(f"✅ Switched to {selected_dataset} dataset! {ai_status}", color="success")
+            
+            data_info = dbc.Alert([
+                html.H6(f"{selected_dataset} Dataset Information:"),
+                html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+                html.P(f"Columns: {', '.join(df.columns.tolist())}"),
+                html.P(f"Data types: {len(df.select_dtypes(include=['number']).columns)} numeric, {len(df.select_dtypes(include=['object']).columns)} categorical")
+            ], color="light")
+            
+            # Create automatic analytics
+            auto_analytics = create_auto_analytics(df)
+            
+            # Create column options for dropdowns
+            all_columns = [{'label': col, 'value': col} for col in df.columns]
+            numeric_columns = [{'label': col, 'value': col} for col in df.select_dtypes(include=['number']).columns]
+            
+            # Set default values - prefer numeric columns for x and y
+            default_x = numeric_columns[0]['value'] if numeric_columns else all_columns[0]['value'] if all_columns else None
+            default_y = numeric_columns[1]['value'] if len(numeric_columns) > 1 else (numeric_columns[0]['value'] if numeric_columns else (all_columns[1]['value'] if len(all_columns) > 1 else None))
+            
+            selector_options = [{"label": name, "value": name} for name in registry.keys()]
+            
+            return df.to_dict('records'), status_msg, table, data_info, auto_analytics, all_columns, all_columns, all_columns, default_x, default_y, registry, selector_options, selected_dataset
+    
+    # Default fallback
+    selector_options = [{"label": name, "value": name} for name in registry.keys()]
+    return None, "", "", "", "", [], [], [], None, None, registry, selector_options, None
+
+# Updated callback for data table (now shared across tabs)
+@app.callback(
+    Output('data-table', 'children'),
+    [Input('stored-data', 'data')]
+)
+def update_data_table(data):
+    """Update data table for data explorer tab"""
+    if not data:
+        return html.P("No data loaded", className="text-muted")
+    
+    df = pd.DataFrame(data)
+    return dbc.Table.from_dataframe(
+        df.head(20), 
+        striped=True, 
+        bordered=True, 
+        hover=True, 
+        size='sm',
+        responsive=True
+    )
+
+# Callback to update AI assistant tab with current dataset info
+@app.callback(
+    Output('ai-dataset-info', 'children'),
+    [Input('stored-data', 'data'),
+     Input('current-dataset-name', 'data')]
+)
+def update_ai_dataset_info(data, dataset_name):
+    """Update AI assistant tab with current dataset information"""
+    if not data or not dataset_name:
+        return dbc.Alert("No dataset loaded. Please load a dataset in the Dataset Management tab first.", 
+                        color="warning", className="mb-3")
+    
+    df = pd.DataFrame(data)
+    return dbc.Alert([
+        html.H6(f"📊 Current Dataset: {dataset_name}"),
+        html.P(f"Shape: {df.shape[0]:,} rows × {df.shape[1]} columns"),
+        html.P(f"Columns: {', '.join(df.columns.tolist()[:5])}{'...' if len(df.columns) > 5 else ''}"),
+        html.P(f"Data types: {len(df.select_dtypes(include=['number']).columns)} numeric, {len(df.select_dtypes(include=['object']).columns)} categorical"),
+        html.Small("✨ AI is ready to answer questions about this data!", className="text-muted")
+    ], color="success", className="mb-3")
+
+@app.callback(
+    Output('ai-response', 'children'),
+    [Input('ask-button', 'n_clicks')],
+    [State('ai-question', 'value'),
+     State('stored-data', 'data'),
+     State('current-dataset-name', 'data')]
+)
+def handle_ai_question(n_clicks, question, data, dataset_name):
+    """Handle AI question"""
+    if not n_clicks or not question or not data:
+        return ""
+    
+    if not dataset_name:
+        return dbc.Alert("Please load a dataset first in the Dataset Management tab.", color="warning")
+    
+    df = pd.DataFrame(data)
+    response = get_ai_response(question, df)
+    
+    return dbc.Alert(
+        dcc.Markdown(response),
+        color="info"
+    )
+
+
+@app.callback(
+    Output('main-graph', 'figure'),
+    [Input('stored-data', 'data'),
+     Input('chart-type', 'value'),
+     Input('x-column', 'value'),
+     Input('y-column', 'value'),
+     Input('color-column', 'value')]
+)
+def update_main_graph(data, chart_type, x_col, y_col, color_col):
+    """Update main visualization based on user selections"""
+    if not data:
+        fig = go.Figure()
+        fig.add_annotation(text="Upload data to see visualizations", 
+                         x=0.5, y=0.5, showarrow=False, 
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig
+    
+    df = pd.DataFrame(data)
+    
+    # Handle cases where columns aren't selected yet
+    if not x_col and not y_col:
+        fig = go.Figure()
+        fig.add_annotation(text="Select columns to create visualization", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig
+    
+    try:
+        # Create visualization based on chart type
+        if chart_type == 'scatter':
+            if x_col and y_col:
+                fig = px.scatter(df, x=x_col, y=y_col, color=color_col,
+                               title=f"Scatter Plot: {y_col} vs {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for scatter plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'line':
+            if x_col and y_col:
+                fig = px.line(df, x=x_col, y=y_col, color=color_col,
+                             title=f"Line Chart: {y_col} vs {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for line chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'bar':
+            if x_col and y_col:
+                fig = px.bar(df, x=x_col, y=y_col, color=color_col,
+                           title=f"Bar Chart: {y_col} by {x_col}")
+            elif x_col:
+                fig = px.bar(df[x_col].value_counts().reset_index(), 
+                           x='index', y=x_col,
+                           title=f"Value Counts: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select at least X column for bar chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'histogram':
+            if x_col:
+                fig = px.histogram(df, x=x_col, color=color_col,
+                                 title=f"Histogram: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for histogram", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'box':
+            if y_col:
+                fig = px.box(df, x=color_col, y=y_col,
+                           title=f"Box Plot: {y_col}" + (f" by {color_col}" if color_col else ""))
+            elif x_col:
+                fig = px.box(df, y=x_col,
+                           title=f"Box Plot: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select a column for box plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'heatmap':
+            numeric_cols = df.select_dtypes(include=['number']).columns
+            if len(numeric_cols) > 1:
+                corr_matrix = df[numeric_cols].corr()
+                fig = px.imshow(corr_matrix, 
+                              text_auto=True, 
+                              aspect="auto",
+                              title="Correlation Heatmap",
+                              color_continuous_scale='RdBu_r')
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Need at least 2 numeric columns for heatmap", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'pie':
+            if x_col:
+                value_counts = df[x_col].value_counts()
+                fig = px.pie(values=value_counts.values, 
+                           names=value_counts.index,
+                           title=f"Pie Chart: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for pie chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        else:
+            fig = go.Figure()
+            fig.add_annotation(text="Select a chart type", 
+                             x=0.5, y=0.5, showarrow=False)
+        
+        fig.update_layout(template="plotly_white", height=500)
+        return fig
+        
+    except Exception as e:
+        fig = go.Figure()
+        fig.add_annotation(text=f"Error creating chart: {str(e)}", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(color="red"))
+        fig.update_layout(template="plotly_white")
+        return fig
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, debug=False)

gradio_demo.py

@@ -0,0 +1,277 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+
+# Simple Gradio examples
+def simple_greet(name):
+    return f"Hello {name}!"
+
+def simple_calculator(x, y, operation):
+    if operation == "add":
+        return x + y
+    elif operation == "subtract":
+        return x - y
+    elif operation == "multiply":
+        return x * y
+    elif operation == "divide":
+        return x / y if y != 0 else "Cannot divide by zero"
+
+# Simple interface examples (uncomment to use)
+# demo1 = gr.Interface(
+#     fn=simple_greet,
+#     inputs="text",
+#     outputs="text",
+#     title="Simple Greeter"
+# )
+
+# demo2 = gr.Interface(
+#     fn=simple_calculator,
+#     inputs=[
+#         gr.Number(label="First Number"),
+#         gr.Number(label="Second Number"), 
+#         gr.Radio(["add", "subtract", "multiply", "divide"], label="Operation")
+#     ],
+#     outputs="text",
+#     title="Calculator"
+# )
+
+def analyze_data(csv_file, chart_type):
+    """Analyze uploaded CSV and return info"""
+    if csv_file is None:
+        return "Please upload a CSV file"
+    
+    try:
+        # Read the CSV file
+        df = pd.read_csv(csv_file.name)
+        
+        # Get basic info
+        info = f"""📊 Dataset Analysis:
+        
+🔢 Shape: {df.shape[0]} rows × {df.shape[1]} columns
+📝 Columns: {', '.join(df.columns.tolist())}
+❌ Missing values: {df.isnull().sum().sum()}
+
+📈 Numeric columns: {len(df.select_dtypes(include=['number']).columns)}
+📋 Text columns: {len(df.select_dtypes(include=['object']).columns)}
+
+💡 Chart type selected: {chart_type}
+
+📋 First 5 rows preview:
+{df.head().to_string()}
+
+📊 Summary statistics:
+{df.describe().to_string() if len(df.select_dtypes(include=['number']).columns) > 0 else 'No numeric data for statistics'}
+        """
+        return info
+        
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+def greet(name, enthusiasm):
+    """Simple greeting function"""
+    excitement = "!" * int(enthusiasm)
+    return f"Hello {name}{excitement}"
+
+def calculator(num1, operation, num2):
+    """Simple calculator"""
+    if operation == "Add":
+        return num1 + num2
+    elif operation == "Subtract":
+        return num1 - num2
+    elif operation == "Multiply":
+        return num1 * num2
+    elif operation == "Divide":
+        return num1 / num2 if num2 != 0 else "Cannot divide by zero!"
+
+# Create Gradio interface with tabs
+with gr.Blocks(title="Gradio Demo App") as demo:
+    gr.Markdown("# 🚀 Gradio Demo Application")
+    gr.Markdown("This demo showcases various Gradio components and functionalities.")
+    
+    with gr.Tab("📊 Data Analysis"):
+        gr.Markdown("## Upload CSV and Create Visualizations")
+        
+        with gr.Row():
+            with gr.Column():
+                csv_input = gr.File(label="Upload CSV File", file_types=[".csv"])
+                chart_dropdown = gr.Dropdown(
+                    choices=["Histogram", "Scatter Plot"], 
+                    label="Chart Type",
+                    value="Histogram"
+                )
+                analyze_btn = gr.Button("Analyze Data", variant="primary")
+            
+            with gr.Column():
+                info_output = gr.Textbox(label="Dataset Info", lines=15, max_lines=20)
+        
+        analyze_btn.click(
+            fn=analyze_data,
+            inputs=[csv_input, chart_dropdown],
+            outputs=info_output
+        )
+    
+    with gr.Tab("👋 Greeting"):
+        gr.Markdown("## Personal Greeting Generator")
+        
+        with gr.Row():
+            name_input = gr.Textbox(label="Your Name", placeholder="Enter your name")
+            enthusiasm_slider = gr.Slider(1, 10, value=3, label="Enthusiasm Level")
+        
+        greet_output = gr.Textbox(label="Greeting")
+        greet_btn = gr.Button("Generate Greeting")
+        
+        greet_btn.click(
+            fn=greet,
+            inputs=[name_input, enthusiasm_slider],
+            outputs=greet_output
+        )
+    
+    with gr.Tab("🧮 Calculator"):
+        gr.Markdown("## Simple Calculator")
+        
+        with gr.Row():
+            num1_input = gr.Number(label="First Number", value=0)
+            operation_radio = gr.Radio(
+                choices=["Add", "Subtract", "Multiply", "Divide"],
+                label="Operation",
+                value="Add"
+            )
+            num2_input = gr.Number(label="Second Number", value=0)
+        
+        calc_output = gr.Number(label="Result")
+        calc_btn = gr.Button("Calculate", variant="secondary")
+        
+        calc_btn.click(
+            fn=calculator,
+            inputs=[num1_input, operation_radio, num2_input],
+            outputs=calc_output
+        )
+    
+    with gr.Tab("🎨 Interactive Demo"):
+        gr.Markdown("## Real-time Updates")
+        
+        with gr.Row():
+            slider_input = gr.Slider(0, 100, value=50, label="Value")
+            checkbox_input = gr.Checkbox(label="Enable Processing", value=True)
+        
+        with gr.Row():
+            text_output = gr.Textbox(label="Live Output")
+            number_output = gr.Number(label="Processed Value")
+        
+        def process_inputs(value, enabled):
+            if enabled:
+                processed = value * 1.5
+                message = f"Processing enabled: {value} → {processed}"
+                return message, processed
+            else:
+                return "Processing disabled", value
+        
+        # Real-time updates
+        slider_input.change(
+            fn=process_inputs,
+            inputs=[slider_input, checkbox_input],
+            outputs=[text_output, number_output]
+        )
+        checkbox_input.change(
+            fn=process_inputs,
+            inputs=[slider_input, checkbox_input],
+            outputs=[text_output, number_output]
+        )
+    
+    with gr.Tab("📝 Basic Examples"):
+        gr.Markdown("## Simple Gradio Code Examples")
+        
+        gr.Markdown("""
+        ### Example 1: Simple Greeter
+        ```python
+        def greet(name):
+            return f"Hello {name}!"
+        
+        demo = gr.Interface(
+            fn=greet,
+            inputs="text",
+            outputs="text"
+        )
+        ```
+        """)
+        
+        with gr.Row():
+            simple_name = gr.Textbox(label="Your Name", placeholder="Enter name")
+            simple_greet_output = gr.Textbox(label="Greeting")
+        
+        simple_greet_btn = gr.Button("Greet Me!")
+        simple_greet_btn.click(
+            fn=simple_greet,
+            inputs=simple_name,
+            outputs=simple_greet_output
+        )
+        
+        gr.Markdown("""
+        ### Example 2: Calculator with Interface
+        ```python
+        def calculator(x, y, operation):
+            if operation == "add":
+                return x + y
+            # ... other operations
+        
+        demo = gr.Interface(
+            fn=calculator,
+            inputs=[
+                gr.Number(label="First Number"),
+                gr.Number(label="Second Number"), 
+                gr.Radio(["add", "subtract", "multiply", "divide"])
+            ],
+            outputs="text"
+        )
+        ```
+        """)
+        
+        with gr.Row():
+            calc_x = gr.Number(label="X", value=0)
+            calc_y = gr.Number(label="Y", value=0)
+            calc_op = gr.Radio(["add", "subtract", "multiply", "divide"], 
+                              label="Operation", value="add")
+        
+        calc_result = gr.Textbox(label="Result")
+        calc_btn = gr.Button("Calculate")
+        
+        calc_btn.click(
+            fn=simple_calculator,
+            inputs=[calc_x, calc_y, calc_op],
+            outputs=calc_result
+        )
+        
+        gr.Markdown("""
+        ### Example 3: Custom Layout with Blocks
+        ```python
+        with gr.Blocks() as demo:
+            gr.Markdown("# My App")
+            
+            with gr.Row():
+                input1 = gr.Textbox()
+                input2 = gr.Slider()
+            
+            output = gr.Textbox()
+            btn = gr.Button("Process")
+            
+            btn.click(fn=my_function, inputs=[input1, input2], outputs=output)
+        
+        demo.launch()
+        ```
+        """)
+        
+        gr.Markdown("**Key Components:**")
+        gr.Markdown("- `gr.Interface()` - Simple wrapper")
+        gr.Markdown("- `gr.Blocks()` - Custom layouts")
+        gr.Markdown("- `gr.Row()`, `gr.Column()` - Layout containers")
+        gr.Markdown("- `gr.Textbox()`, `gr.Number()`, `gr.Slider()` - Input components")
+        gr.Markdown("- `demo.launch()` - Start the server")
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",  # Allow external access
+        server_port=7861,       # Different port from Dash app
+        share=False,           # Set to True to create public link
+        debug=True             # Enable debug mode
+    )

requirements.txt

@@ -4,6 +4,7 @@ dash==2.17.1
 dash-bootstrap-components==1.5.0
 numpy==1.24.3
 openpyxl==3.1.2
+scikit-learn==1.3.2
 
 # Fixed Langchain components
 langchain==0.2.6
@@ -18,5 +19,7 @@ torch==2.1.0
 tokenizers==0.19.1
 pydantic==2.5.0
 
-# Additional utilities
-python-dotenv==1.0.0
+# Additional utilities for AI assistant
+python-dotenv==1.0.0
+matplotlib==3.7.5
+seaborn==0.12.2

simple_app.py

@@ -0,0 +1,370 @@
+import os
+import base64
+import io
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from dash import Dash, html, dcc, Input, Output, State, callback_context
+import dash_bootstrap_components as dbc
+
+# Initialize Dash app
+app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
+server = app.server
+
+# App layout
+app.layout = dbc.Container([
+    dbc.Row([
+        dbc.Col([
+            html.H1("📊 Interactive Data Dashboard", className="text-center mb-4"),
+            html.P("Upload data and create interactive visualizations with different chart types!", 
+                   className="text-center text-muted"),
+            html.Hr(),
+        ], width=12)
+    ]),
+    
+    dbc.Row([
+        dbc.Col([
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("📁 Data Upload", className="card-title"),
+                    dcc.Upload(
+                        id='upload-data',
+                        children=html.Div([
+                            'Drag and Drop or ',
+                            html.A('Select Files')
+                        ]),
+                        style={
+                            'width': '100%',
+                            'height': '60px',
+                            'lineHeight': '60px',
+                            'borderWidth': '1px',
+                            'borderStyle': 'dashed',
+                            'borderRadius': '5px',
+                            'textAlign': 'center',
+                            'margin': '10px'
+                        },
+                        multiple=False,
+                        accept='.csv,.xlsx,.txt'
+                    ),
+                    
+                    html.Div(id='upload-status', className="mt-2"),
+                    html.Hr(),
+                    
+                    html.H4("📊 Quick Analytics", className="card-title"),
+                    dbc.ButtonGroup([
+                        dbc.Button("Summary Stats", id="stats-btn", size="sm"),
+                        dbc.Button("Correlations", id="corr-btn", size="sm"),
+                        dbc.Button("Missing Data", id="missing-btn", size="sm"),
+                    ], className="w-100"),
+                    
+                    html.Div(id="quick-analytics", className="mt-3")
+                ])
+            ])
+        ], width=4),
+        
+        dbc.Col([
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("📈 Visualizations", className="card-title"),
+                    
+                    # Chart controls
+                    dbc.Row([
+                        dbc.Col([
+                            html.Label("Chart Type:", className="form-label"),
+                            dcc.Dropdown(
+                                id='chart-type',
+                                options=[
+                                    {'label': 'Scatter Plot', 'value': 'scatter'},
+                                    {'label': 'Line Chart', 'value': 'line'},
+                                    {'label': 'Bar Chart', 'value': 'bar'},
+                                    {'label': 'Histogram', 'value': 'histogram'},
+                                    {'label': 'Box Plot', 'value': 'box'},
+                                    {'label': 'Heatmap', 'value': 'heatmap'},
+                                    {'label': 'Pie Chart', 'value': 'pie'}
+                                ],
+                                value='scatter',
+                                className="mb-2"
+                            )
+                        ], width=6),
+                        dbc.Col([
+                            html.Label("Color By:", className="form-label"),
+                            dcc.Dropdown(
+                                id='color-column',
+                                placeholder="Select column (optional)",
+                                className="mb-2"
+                            )
+                        ], width=6)
+                    ]),
+                    
+                    dbc.Row([
+                        dbc.Col([
+                            html.Label("X-Axis:", className="form-label"),
+                            dcc.Dropdown(
+                                id='x-column',
+                                placeholder="Select X column"
+                            )
+                        ], width=6),
+                        dbc.Col([
+                            html.Label("Y-Axis:", className="form-label"),
+                            dcc.Dropdown(
+                                id='y-column',
+                                placeholder="Select Y column"
+                            )
+                        ], width=6)
+                    ], className="mb-3"),
+                    
+                    dcc.Graph(id='main-graph', style={'height': '500px'}),
+                ])
+            ]),
+            
+            dbc.Card([
+                dbc.CardBody([
+                    html.H4("🔍 Data Explorer", className="card-title"),
+                    html.Div(id='data-table')
+                ])
+            ], className="mt-3")
+        ], width=8)
+    ], className="mt-4"),
+    
+    # Store components
+    dcc.Store(id='stored-data'),
+], fluid=True)
+
+def parse_contents(contents, filename):
+    """Parse uploaded file contents"""
+    content_type, content_string = contents.split(',')
+    decoded = base64.b64decode(content_string)
+    
+    try:
+        if 'csv' in filename:
+            df = pd.read_csv(io.StringIO(decoded.decode('utf-8')))
+        elif 'xls' in filename:
+            df = pd.read_excel(io.BytesIO(decoded))
+        else:
+            return None, "Unsupported file type"
+        
+        return df, None
+    except Exception as e:
+        return None, f"Error processing file: {str(e)}"
+
+@app.callback(
+    [Output('stored-data', 'data'),
+     Output('upload-status', 'children'),
+     Output('data-table', 'children'),
+     Output('x-column', 'options'),
+     Output('y-column', 'options'),
+     Output('color-column', 'options'),
+     Output('x-column', 'value'),
+     Output('y-column', 'value')],
+    [Input('upload-data', 'contents')],
+    [State('upload-data', 'filename')]
+)
+def update_data(contents, filename):
+    """Update data when file is uploaded"""
+    if contents is None:
+        return None, "", "", [], [], [], None, None
+    
+    df, error = parse_contents(contents, filename)
+    
+    if error:
+        return None, dbc.Alert(error, color="danger"), "", [], [], [], None, None
+    
+    # Create data table preview
+    table = dbc.Table.from_dataframe(
+        df.head(10), 
+        striped=True, 
+        bordered=True, 
+        hover=True, 
+        size='sm'
+    )
+    
+    success_msg = dbc.Alert([
+        html.H6(f"✅ File uploaded successfully!"),
+        html.P(f"Shape: {df.shape[0]} rows × {df.shape[1]} columns"),
+        html.P(f"Columns: {', '.join(df.columns.tolist())}")
+    ], color="success")
+    
+    # Create column options for dropdowns
+    all_columns = [{'label': col, 'value': col} for col in df.columns]
+    numeric_columns = [{'label': col, 'value': col} for col in df.select_dtypes(include=['number']).columns]
+    
+    # Set default values - prefer numeric columns for x and y
+    default_x = numeric_columns[0]['value'] if numeric_columns else all_columns[0]['value'] if all_columns else None
+    default_y = numeric_columns[1]['value'] if len(numeric_columns) > 1 else (numeric_columns[0]['value'] if numeric_columns else (all_columns[1]['value'] if len(all_columns) > 1 else None))
+    
+    return df.to_dict('records'), success_msg, table, all_columns, all_columns, all_columns, default_x, default_y
+
+@app.callback(
+    Output('quick-analytics', 'children'),
+    [Input('stats-btn', 'n_clicks'),
+     Input('corr-btn', 'n_clicks'),
+     Input('missing-btn', 'n_clicks')],
+    [State('stored-data', 'data')]
+)
+def quick_analytics(stats_clicks, corr_clicks, missing_clicks, data):
+    """Handle quick analytics buttons"""
+    if not data:
+        return ""
+    
+    df = pd.DataFrame(data)
+    ctx = callback_context
+    
+    if not ctx.triggered:
+        return ""
+    
+    button_id = ctx.triggered[0]['prop_id'].split('.')[0]
+    
+    if button_id == 'stats-btn':
+        stats = df.describe()
+        return dbc.Alert([
+            html.H6("📊 Summary Statistics"),
+            dbc.Table.from_dataframe(stats.reset_index(), size='sm')
+        ], color="light")
+    
+    elif button_id == 'corr-btn':
+        numeric_df = df.select_dtypes(include=['number'])
+        if len(numeric_df.columns) > 1:
+            corr = numeric_df.corr()
+            fig = px.imshow(corr, text_auto=True, aspect="auto", 
+                          title="Correlation Matrix")
+            return dcc.Graph(figure=fig, style={'height': '300px'})
+        return dbc.Alert("No numeric columns for correlation analysis", color="warning")
+    
+    elif button_id == 'missing-btn':
+        missing = df.isnull().sum()
+        missing = missing[missing > 0]
+        if missing.empty:
+            return dbc.Alert("✅ No missing values!", color="success")
+        return dbc.Alert([
+            html.H6("⚠️ Missing Values"),
+            html.Pre(missing.to_string())
+        ], color="warning")
+    
+    return ""
+
+@app.callback(
+    Output('main-graph', 'figure'),
+    [Input('stored-data', 'data'),
+     Input('chart-type', 'value'),
+     Input('x-column', 'value'),
+     Input('y-column', 'value'),
+     Input('color-column', 'value')]
+)
+def update_main_graph(data, chart_type, x_col, y_col, color_col):
+    """Update main visualization based on user selections"""
+    if not data:
+        fig = go.Figure()
+        fig.add_annotation(text="Upload data to see visualizations", 
+                         x=0.5, y=0.5, showarrow=False, 
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig
+    
+    df = pd.DataFrame(data)
+    
+    # Handle cases where columns aren't selected yet
+    if not x_col and not y_col:
+        fig = go.Figure()
+        fig.add_annotation(text="Select columns to create visualization", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(size=16, color="gray"))
+        fig.update_layout(template="plotly_white")
+        return fig
+    
+    try:
+        # Create visualization based on chart type
+        if chart_type == 'scatter':
+            if x_col and y_col:
+                fig = px.scatter(df, x=x_col, y=y_col, color=color_col,
+                               title=f"Scatter Plot: {y_col} vs {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for scatter plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'line':
+            if x_col and y_col:
+                fig = px.line(df, x=x_col, y=y_col, color=color_col,
+                             title=f"Line Chart: {y_col} vs {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select both X and Y columns for line chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'bar':
+            if x_col and y_col:
+                fig = px.bar(df, x=x_col, y=y_col, color=color_col,
+                           title=f"Bar Chart: {y_col} by {x_col}")
+            elif x_col:
+                fig = px.bar(df[x_col].value_counts().reset_index(), 
+                           x='index', y=x_col,
+                           title=f"Value Counts: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select at least X column for bar chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'histogram':
+            if x_col:
+                fig = px.histogram(df, x=x_col, color=color_col,
+                                 title=f"Histogram: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for histogram", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'box':
+            if y_col:
+                fig = px.box(df, x=color_col, y=y_col,
+                           title=f"Box Plot: {y_col}" + (f" by {color_col}" if color_col else ""))
+            elif x_col:
+                fig = px.box(df, y=x_col,
+                           title=f"Box Plot: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select a column for box plot", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'heatmap':
+            numeric_cols = df.select_dtypes(include=['number']).columns
+            if len(numeric_cols) > 1:
+                corr_matrix = df[numeric_cols].corr()
+                fig = px.imshow(corr_matrix, 
+                              text_auto=True, 
+                              aspect="auto",
+                              title="Correlation Heatmap",
+                              color_continuous_scale='RdBu_r')
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Need at least 2 numeric columns for heatmap", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        elif chart_type == 'pie':
+            if x_col:
+                value_counts = df[x_col].value_counts()
+                fig = px.pie(values=value_counts.values, 
+                           names=value_counts.index,
+                           title=f"Pie Chart: {x_col}")
+            else:
+                fig = go.Figure()
+                fig.add_annotation(text="Select X column for pie chart", 
+                                 x=0.5, y=0.5, showarrow=False)
+        
+        else:
+            fig = go.Figure()
+            fig.add_annotation(text="Select a chart type", 
+                             x=0.5, y=0.5, showarrow=False)
+        
+        fig.update_layout(template="plotly_white", height=500)
+        return fig
+        
+    except Exception as e:
+        fig = go.Figure()
+        fig.add_annotation(text=f"Error creating chart: {str(e)}", 
+                         x=0.5, y=0.5, showarrow=False,
+                         font=dict(color="red"))
+        fig.update_layout(template="plotly_white")
+        return fig
+
+if __name__ == '__main__':
+    app.run_server(host='0.0.0.0', port=8050, debug=True)

simple_gradio.py

@@ -0,0 +1,81 @@
+import gradio as gr
+import plotly.graph_objects as go
+from datasets import load_dataset
+
+# Load dataset once
+dataset = load_dataset("gradio/NYC-Airbnb-Open-Data", split="train")
+df = dataset.to_pandas()
+
+def filter_map(min_price, max_price, boroughs):
+    # Handle empty boroughs list
+    if not boroughs:
+        boroughs = ["Queens", "Brooklyn", "Manhattan", "Bronx", "Staten Island"]
+    
+    # Filter dataframe
+    filtered_df = df[(df['neighbourhood_group'].isin(boroughs)) &
+                    (df['price'] > min_price) & (df['price'] < max_price)]
+    
+    # Handle empty results
+    if filtered_df.empty:
+        # Return empty map
+        fig = go.Figure()
+        fig.update_layout(
+            title="No properties found with current filters",
+            mapbox_style="open-street-map",
+            mapbox=dict(
+                center=go.layout.mapbox.Center(lat=40.67, lon=-73.90),
+                zoom=9
+            ),
+        )
+        return fig
+    
+    # Prepare data for map
+    names = filtered_df["name"].tolist()
+    prices = filtered_df["price"].tolist()
+    text_list = [(names[i], prices[i]) for i in range(len(names))]
+    
+    # Create map
+    fig = go.Figure(go.Scattermapbox(
+        customdata=text_list,
+        lat=filtered_df['latitude'].tolist(),
+        lon=filtered_df['longitude'].tolist(),
+        mode='markers',
+        marker=go.scattermapbox.Marker(
+            size=6,
+            color='red',
+            opacity=0.7
+        ),
+        hoverinfo="text",
+        hovertemplate='<b>Name</b>: %{customdata[0]}<br><b>Price</b>: $%{customdata[1]}<extra></extra>'
+    ))
+
+    fig.update_layout(
+        title=f"Found {len(filtered_df)} properties",
+        mapbox_style="open-street-map",
+        hovermode='closest',
+        mapbox=dict(
+            bearing=0,
+            center=go.layout.mapbox.Center(
+                lat=40.67,
+                lon=-73.90
+            ),
+            pitch=0,
+            zoom=9
+        ),
+        height=600
+    )
+
+    return fig
+
+with gr.Blocks() as demo:
+    with gr.Column():
+        with gr.Row():
+            min_price = gr.Number(value=250, label="Minimum Price")
+            max_price = gr.Number(value=1000, label="Maximum Price")
+        boroughs = gr.CheckboxGroup(choices=["Queens", "Brooklyn", "Manhattan", "Bronx", "Staten Island"], value=["Queens", "Brooklyn"], label="Select Boroughs:")
+        btn = gr.Button(value="Update Filter")
+        map = gr.Plot()
+    demo.load(filter_map, [min_price, max_price, boroughs], map)
+    btn.click(filter_map, [min_price, max_price, boroughs], map)
+
+demo.launch()