Added frontend pages and links

frontend/.env.example

@@ -0,0 +1,5 @@
+# Backend Configuration
+BACKEND_URL=http://localhost:8000
+
+# Optional: Streamlit specific
+STREAMLIT_SERVER_HEADLESS=false

frontend/.streamlit/config.toml

@@ -0,0 +1,13 @@
+[theme]
+primaryColor = "#208080"
+backgroundColor = "#f5f5f5"
+secondaryBackgroundColor = "#e0e0e0"
+textColor = "#262730"
+font = "sans serif"
+
+[client]
+showErrorDetails = true
+
+[server]
+port = 8501
+headless = false

frontend/README.md

@@ -0,0 +1,9 @@
+# LLM Data Analyzer Frontend
+
+Streamlit-based frontend for the LLM Data Analyzer backend.
+
+## Installation
+
+```bash
+cd frontend
+uv pip install -r requirements.txt

frontend/app.py

@@ -0,0 +1,72 @@
+"""Main Streamlit app"""
+import streamlit as st
+from components import render_sidebar
+from utils import PAGE_TITLE, PAGE_ICON
+
+st.set_page_config(
+    page_title=PAGE_TITLE,
+    page_icon=PAGE_ICON,
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+render_sidebar()
+
+st.title("🤖 LLM Data Analyzer")
+st.subtitle("Advanced data analysis with AI assistance")
+
+st.divider()
+
+# Home page content
+col1, col2 = st.columns(2)
+
+with col1:
+    st.subheader("💬 Chat")
+    st.write("""
+    - Ask questions about data analysis
+    - Get AI-powered insights
+    - Real-time responses from LLM
+    """)
+    st.page_link("pages/01_Chat.py", label="Go to Chat", icon="💬")
+
+with col2:
+    st.subheader("📁 Upload Data")
+    st.write("""
+    - Upload CSV or Excel files
+    - Preview your data
+    - View statistics
+    """)
+    st.page_link("pages/02_Upload_Data.py", label="Upload Data", icon="📁")
+
+st.divider()
+
+col3, col4 = st.columns(2)
+
+with col3:
+    st.subheader("📊 Analysis")
+    st.write("""
+    - Statistical analysis
+    - Trend detection
+    - Outlier detection
+    - Correlation analysis
+    """)
+    st.page_link("pages/03_Analysis.py", label="Run Analysis", icon="📊")
+
+with col4:
+    st.subheader("🏥 System Status")
+    st.write("""
+    - Check backend health
+    - View LLM model info
+    - Monitor system status
+    """)
+    st.page_link("pages/04_Health_Check.py", label="Check Status", icon="🏥")
+
+st.divider()
+
+st.info("""
+### 📖 Quick Start
+1. **Upload Data** - Start by uploading a CSV or Excel file
+2. **Preview** - Review your data and statistics
+3. **Analyze** - Run analysis and get insights
+4. **Chat** - Ask follow-up questions to the AI
+""")

frontend/components/__init__.py

@@ -0,0 +1,3 @@
+from .sidebar import render_sidebar
+from .chat_widget import render_chat
+from .data_display import display_data_preview, display_analysis_results

frontend/components/chat_widget.py

@@ -0,0 +1,57 @@
+"""Chat interface component"""
+import streamlit as st
+from utils import client
+
+
+def render_chat():
+    """Render chat interface"""
+    st.subheader("💬 Chat with LLM")
+    
+    # Chat history
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    
+    # Display chat history
+    for message in st.session_state.chat_history:
+        with st.chat_message(message["role"]):
+            st.write(message["content"])
+    
+    # Input
+    system_prompt = st.text_area(
+        "System Prompt",
+        value="You are a helpful data analysis assistant.",
+        height=80
+    )
+    
+    user_input = st.chat_input("Type your message...")
+    
+    if user_input:
+        # Add user message
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+        
+        with st.chat_message("user"):
+            st.write(user_input)
+        
+        # Get response
+        with st.spinner("🤖 Thinking..."):
+            messages = [
+                {"role": "user", "content": user_input}
+            ]
+            response = client.chat(messages, system_prompt)
+            
+            if "error" in response:
+                st.error(f"Error: {response['error']}")
+            else:
+                assistant_response = response.get("response", "No response")
+                st.session_state.chat_history.append({
+                    "role": "assistant",
+                    "content": assistant_response
+                })
+                
+                with st.chat_message("assistant"):
+                    st.write(assistant_response)
+                
+                # Show model info
+                st.caption(f"Model: {response.get('model', 'Unknown')}")
+        
+        st.rerun()

frontend/components/data_display.py

@@ -0,0 +1,51 @@
+"""Data display utilities"""
+import streamlit as st
+import pandas as pd
+
+
+def display_data_preview(data: list, columns: list):
+    """Display data preview"""
+    if not data:
+        st.warning("No data to display")
+        return
+    
+    st.subheader("📋 Data Preview")
+    
+    # Convert to DataFrame for better display
+    df = pd.DataFrame(data)
+    
+    # Display summary
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.metric("Total Rows", len(df))
+    with col2:
+        st.metric("Total Columns", len(df.columns))
+    with col3:
+        st.metric("Memory Usage", f"{df.memory_usage().sum() / 1024:.2f} KB")
+    
+    st.divider()
+    
+    # Display data table
+    st.dataframe(df, use_container_width=True)
+    
+    st.divider()
+    
+    # Display statistics
+    st.subheader("📊 Data Statistics")
+    st.dataframe(df.describe(), use_container_width=True)
+
+
+def display_analysis_results(results: dict):
+    """Display analysis results"""
+    st.subheader("📈 Analysis Results")
+    
+    if "error" in results:
+        st.error(f"Analysis failed: {results['error']}")
+        return
+    
+    # Display results based on type
+    if "results" in results:
+        st.write(results["results"])
+    
+    if "summary" in results:
+        st.info(f"**Summary:** {results['summary']}")

frontend/components/sidebar.py

@@ -0,0 +1,48 @@
+"""Sidebar navigation"""
+import streamlit as st
+from utils import client
+
+
+def render_sidebar():
+    """Render sidebar with navigation and status"""
+    with st.sidebar:
+        st.title("🤖 LLM Data Analyzer")
+        
+        st.divider()
+        
+        # Navigation
+        st.subheader("Navigation")
+        st.page_link("app.py", label="🏠 Home", icon="🏠")
+        st.page_link("pages/01_Chat.py", label="💬 Chat", icon="💬")
+        st.page_link("pages/02_Upload_Data.py", label="📁 Upload Data", icon="📁")
+        st.page_link("pages/03_Analysis.py", label="📊 Analysis", icon="📊")
+        st.page_link("pages/04_Health_Check.py", label="🏥 Health Check", icon="🏥")
+        
+        st.divider()
+        
+        # Backend Status
+        st.subheader("Backend Status")
+        if st.button("🔄 Check Status"):
+            with st.spinner("Checking..."):
+                health = client.health_check()
+                if health.get("status") == "healthy":
+                    st.success(f"✅ Connected - {health.get('llm_model')}")
+                else:
+                    st.error("❌ Backend not responding")
+        
+        st.divider()
+        
+        # Settings
+        st.subheader("Settings")
+        backend_url = st.text_input(
+            "Backend URL",
+            value="http://localhost:8000",
+            help="Change if backend is running elsewhere"
+        )
+        
+        st.divider()
+        
+        # About
+        st.subheader("About")
+        st.caption("LLM Data Analyzer Frontend")
+        st.caption("Built with Streamlit & FastAPI")

frontend/pages/01_chat.py

@@ -0,0 +1,7 @@
+"""Chat page"""
+import streamlit as st
+from components import render_sidebar, render_chat
+
+st.set_page_config(page_title="Chat", page_icon="💬")
+render_sidebar()
+render_chat()

frontend/pages/02_upload_data.py

@@ -0,0 +1,44 @@
+"""File upload and preview page"""
+import streamlit as st
+from components import render_sidebar, display_data_preview
+from utils import client
+
+st.set_page_config(page_title="Upload Data", page_icon="📁")
+render_sidebar()
+
+st.title("📁 Upload & Preview Data")
+
+st.subheader("Upload File")
+uploaded_file = st.file_uploader(
+    "Choose a file (CSV or Excel)",
+    type=["csv", "xlsx", "xls"],
+    help="Upload your data file for analysis"
+)
+
+if uploaded_file:
+    with st.spinner("📤 Uploading file..."):
+        file_bytes = uploaded_file.read()
+        result = client.upload_file(file_bytes, uploaded_file.name)
+        
+        if "error" in result:
+            st.error(f"Upload failed: {result['error']}")
+        else:
+            st.success(f"✅ File uploaded: {result['filename']}")
+            
+            # Store data in session state
+            st.session_state.uploaded_data = result.get("preview", [])
+            st.session_state.all_columns = result.get("column_names", [])
+            
+            # Display file info
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Rows", result.get("rows", 0))
+            with col2:
+                st.metric("Columns", result.get("columns", 0))
+            with col3:
+                st.metric("File Type", result.get("file_type", "unknown").upper())
+            
+            st.divider()
+            
+            # Display preview
+            display_data_preview(result.get("preview", []), result.get("column_names", []))

frontend/pages/03_Analysis.py

@@ -0,0 +1,54 @@
+"""Data analysis page"""
+import streamlit as st
+from components import render_sidebar, display_analysis_results
+from utils import client, get_analysis_types
+
+st.set_page_config(page_title="Analysis", page_icon="📊")
+render_sidebar()
+
+st.title("📊 Data Analysis")
+
+if "uploaded_data" not in st.session_state or not st.session_state.uploaded_data:
+    st.warning("⚠️ Please upload data first on the 'Upload Data' page")
+    st.stop()
+
+data = st.session_state.uploaded_data
+columns = st.session_state.get("all_columns", [])
+
+st.subheader("Analysis Settings")
+
+col1, col2 = st.columns(2)
+with col1:
+    analysis_type = st.selectbox(
+        "Analysis Type",
+        get_analysis_types(),
+        help="Choose the type of analysis to perform"
+    )
+
+with col2:
+    selected_columns = st.multiselect(
+        "Columns to Analyze",
+        columns,
+        default=columns[:3] if len(columns) > 3 else columns,
+        help="Select which columns to analyze"
+    )
+
+st.divider()
+
+if st.button("🔍 Run Analysis", use_container_width=True):
+    with st.spinner("📊 Analyzing data..."):
+        result = client.analyze(data, analysis_type, selected_columns)
+        
+        if "error" in result:
+            st.error(f"Analysis failed: {result['error']}")
+        else:
+            display_analysis_results(result)
+            
+            # Show suggestions
+            if st.checkbox("💡 Get AI Suggestions"):
+                with st.spinner("🤖 Generating suggestions..."):
+                    suggestions = client.get_suggestions(data, f"Analysis type: {analysis_type}")
+                    if "suggestions" in suggestions:
+                        st.subheader("💡 Suggestions")
+                        for i, suggestion in enumerate(suggestions["suggestions"], 1):
+                            st.write(f"{i}. {suggestion}")

frontend/pages/04_Health_Check.py

@@ -0,0 +1,36 @@
+"""System health check page"""
+import streamlit as st
+from components import render_sidebar
+from utils import client
+
+st.set_page_config(page_title="Health Check", page_icon="🏥")
+render_sidebar()
+
+st.title("🏥 System Health Check")
+
+if st.button("🔄 Check Backend Status", use_container_width=True):
+    with st.spinner("Checking..."):
+        health = client.health_check()
+        
+        if health.get("status") == "healthy":
+            st.success("✅ Backend is running and healthy!")
+            
+            # Display details
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric("Status", health.get("status", "unknown"))
+                st.metric("Service", health.get("service", "unknown"))
+            
+            with col2:
+                st.metric("LLM Model", health.get("llm_model", "unknown"))
+                st.metric("Environment", health.get("environment", "unknown"))
+            
+            st.divider()
+            
+            # Display full response
+            st.subheader("📋 Full Response")
+            st.json(health)
+        else:
+            st.error("❌ Backend is not responding or unhealthy")
+            if "detail" in health:
+                st.error(f"Details: {health['detail']}")

frontend/requirements.txt

@@ -0,0 +1,5 @@
+streamlit>=1.28.0
+requests>=2.31.0
+pandas>=2.0.0
+plotly>=5.17.0
+python-dotenv>=1.0.0

frontend/utils/__init__.py

@@ -0,0 +1,3 @@
+from .api_client import client
+from .config import *
+from .helpers import *

frontend/utils/api_client.py

@@ -0,0 +1,110 @@
+"""API client for backend communication"""
+import requests
+import logging
+from typing import Dict, List, Any
+
+logger = logging.getLogger(__name__)
+
+# Import config
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+API_BASE_URL = f"{BACKEND_URL}/api/v1"
+TIMEOUT_LONG = 120
+
+
+class APIClient:
+    """Client for backend API communication"""
+    
+    def __init__(self):
+        self.base_url = API_BASE_URL
+        self.timeout = TIMEOUT_LONG
+    
+    def health_check(self) -> Dict[str, Any]:
+        """Check backend health status"""
+        try:
+            response = requests.get(
+                f"{self.base_url}/health",
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"❌ Health check failed: {e}")
+            return {"status": "error", "detail": str(e)}
+    
+    def chat(self, messages: List[Dict], system_prompt: str = None) -> Dict[str, Any]:
+        """Send chat request to backend"""
+        try:
+            payload = {
+                "messages": messages,
+                "system_prompt": system_prompt or "You are a helpful data analysis assistant."
+            }
+            response = requests.post(
+                f"{self.base_url}/chat",
+                json=payload,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"❌ Chat request failed: {e}")
+            return {"error": str(e)}
+    
+    def upload_file(self, file_bytes: bytes, filename: str) -> Dict[str, Any]:
+        """Upload file to backend"""
+        try:
+            files = {"file": (filename, file_bytes)}
+            response = requests.post(
+                f"{self.base_url}/upload",
+                files=files,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"❌ File upload failed: {e}")
+            return {"error": str(e)}
+    
+    def analyze(self, data: List[Dict], analysis_type: str, columns: List[str] = None) -> Dict[str, Any]:
+        """Request data analysis"""
+        try:
+            payload = {
+                "data": data,
+                "analysis_type": analysis_type,
+                "columns": columns or []
+            }
+            response = requests.post(
+                f"{self.base_url}/analyze",
+                json=payload,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"❌ Analysis request failed: {e}")
+            return {"error": str(e)}
+    
+    def get_suggestions(self, data: List[Dict], context: str = None) -> Dict[str, Any]:
+        """Get AI suggestions for data"""
+        try:
+            payload = {
+                "data": data,
+                "analysis_context": context or ""
+            }
+            response = requests.post(
+                f"{self.base_url}/suggestions",
+                json=payload,
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            logger.error(f"❌ Suggestion request failed: {e}")
+            return {"error": str(e)}
+
+
+# Global client instance
+client = APIClient()

frontend/utils/config.py

@@ -0,0 +1,17 @@
+"""Configuration for frontend"""
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Backend API
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+API_BASE_URL = f"{BACKEND_URL}/api/v1"
+
+# Timeouts
+TIMEOUT_SHORT = 5
+TIMEOUT_LONG = 120
+
+# UI Settings
+PAGE_TITLE = "LLM Data Analyzer"
+PAGE_ICON = "🤖"

frontend/utils/helpers.py

@@ -0,0 +1,37 @@
+"""Helper functions"""
+import streamlit as st
+from datetime import datetime
+
+
+def format_timestamp(ts: str) -> str:
+    """Format timestamp for display"""
+    try:
+        dt = datetime.fromisoformat(ts)
+        return dt.strftime("%Y-%m-%d %H:%M:%S")
+    except:
+        return ts
+
+
+def get_analysis_types() -> list:
+    """Get available analysis types"""
+    return [
+        "statistical_summary",
+        "trend_detection",
+        "outlier_detection",
+        "correlation_analysis"
+    ]
+
+
+def display_error(error_msg: str):
+    """Display error message"""
+    st.error(f"❌ Error: {error_msg}")
+
+
+def display_success(success_msg: str):
+    """Display success message"""
+    st.success(f"✅ {success_msg}")
+
+
+def display_info(info_msg: str):
+    """Display info message"""
+    st.info(f"ℹ️ {info_msg}")