Update app.py

app.py

@@ -6,8 +6,8 @@ import base64
 import io
 import matplotlib.pyplot as plt
 import seaborn as sns
-from abc import ABC, abstractmethod  # For abstract base classes
-from sklearn.model_selection import train_test_split # Machine learning modules
+from abc import ABC, abstractmethod
+from sklearn.model_selection import train_test_split
 from sklearn.linear_model import LogisticRegression
 from sklearn.metrics import accuracy_score
 from statsmodels.tsa.seasonal import seasonal_decompose
@@ -17,177 +17,216 @@ from groq import Groq
 import os
 import numpy as np
 from scipy.stats import ttest_ind, f_oneway
+import json
 
 # Initialize Groq Client
 client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
 
+# ---------------------- Data Acquisition Layer ---------------------------
+class DataSource(ABC):
+    """Base class for data sources."""
+    @abstractmethod
+    def connect(self) -> None:
+        """Connect to the data source."""
+        pass
+    
+    @abstractmethod
+    def fetch_data(self, query: str, **kwargs) -> pd.DataFrame:
+         """Fetch the data based on a specific query."""
+         pass
 
-# ---------------------- Base Classes and Schemas ---------------------------
-class ResearchInput(BaseModel):
-    """Base schema for research tool inputs"""
-    data_key: str = Field(..., description="Session state key containing DataFrame")
-    columns: Optional[List[str]] = Field(None, description="List of columns to analyze")
 
-class TemporalAnalysisInput(ResearchInput):
-    """Schema for temporal analysis"""
-    time_col: str = Field(..., description="Name of timestamp column")
-    value_col: str = Field(..., description="Name of value column to analyze")
+class CSVDataSource(DataSource):
+    """Data source for CSV files."""
+    def __init__(self, file_path: str):
+        self.file_path = file_path
+        self.data: Optional[pd.DataFrame] = None
+    
+    def connect(self):
+        self.data = pd.read_csv(self.file_path)
+    
+    def fetch_data(self, query: str = None, **kwargs) -> pd.DataFrame:
+      if self.data is None:
+        raise Exception("No connection is made, call connect()")
+      return self.data
+    
+class DatabaseSource(DataSource):
+   def __init__(self, connection_string: str, database_type: str):
+        self.connection_string = connection_string
+        self.database_type = database_type
+        self.connection = None
+    
+   def connect(self):
+     if self.database_type.lower() == "sql":
+        #Placeholder for the actual database connection
+        self.connection = "Connected to SQL Database"
+     else:
+        raise Exception(f"Database type '{self.database_type}' is not supported")
+      
+   def fetch_data(self, query: str, **kwargs) -> pd.DataFrame:
+        if self.connection is None:
+            raise Exception("No connection is made, call connect()")
+        #Placeholder for the data fetching
+        return pd.DataFrame({"result":[f"Fetched data based on query: {query}"]})
+     
 
-class HypothesisInput(ResearchInput):
-    """Schema for hypothesis testing"""
-    group_col: str = Field(..., description="Categorical column defining groups")
-    value_col: str = Field(..., description="Numerical column to compare")
+class DataIngestion:
+    def __init__(self):
+      self.sources : Dict[str, DataSource] = {}
+    
+    def add_source(self, source_name: str, source: DataSource):
+         self.sources[source_name] = source
+    
+    def ingest_data(self, source_name: str, query: str = None, **kwargs) -> pd.DataFrame:
+       if source_name not in self.sources:
+         raise Exception(f"Source '{source_name}' not found")
+       source = self.sources[source_name]
+       source.connect()
+       return source.fetch_data(query, **kwargs)
+       
+class DataModel(BaseModel):
+  name : str
+  kpis : List[str] = Field(default_factory=list)
+  dimensions : List[str] = Field(default_factory=list)
+  custom_calculations : Optional[Dict[str, str]] = None
+  relations: Optional[Dict[str,str]] = None #Example {table1: table2}
+  
+  def to_json(self):
+    return json.dumps(self.dict())
+  
+  @staticmethod
+  def from_json(json_str):
+    return DataModel(**json.loads(json_str))
+  
+class DataModelling():
+    def __init__(self):
+      self.models : Dict[str, DataModel] = {}
+    
+    def add_model(self, model:DataModel):
+       self.models[model.name] = model
+    
+    def get_model(self, model_name: str) -> DataModel:
+      if model_name not in self.models:
+          raise Exception(f"Model '{model_name}' not found")
+      return self.models[model_name]
+# ---------------------- Business Logic Layer ---------------------------
+class BusinessRule(BaseModel):
+  name: str
+  condition: str
+  action: str
 
-class ModelTrainingInput(ResearchInput):
-    """Schema for model training"""
-    target_col: str = Field(..., description="Name of target column")
+class BusinessRulesEngine():
+    def __init__(self):
+       self.rules: Dict[str, BusinessRule] = {}
+    
+    def add_rule(self, rule: BusinessRule):
+        self.rules[rule.name] = rule
 
-class DataAnalyzer(ABC):
-    """Abstract base class for data analysis modules"""
+    def execute_rules(self, data: pd.DataFrame):
+        results = {}
+        for rule_name, rule in self.rules.items():
+            try:
+              if eval(rule.condition, {}, {"df":data}):
+                results[rule_name] = {"rule_matched": True, "action": rule.action}
+              else:
+                results[rule_name] = {"rule_matched": False, "action": None}
+            except Exception as e:
+                 results[rule_name] = {"rule_matched": False, "error": str(e)}
+        return results
+
+class KPI(BaseModel):
+  name: str
+  calculation: str
+  threshold: Optional[float] = None
+  
+class KPIMonitoring():
+  def __init__(self):
+    self.kpis : Dict[str, KPI] = {}
+    
+  def add_kpi(self, kpi:KPI):
+    self.kpis[kpi.name] = kpi
+    
+  def calculate_kpis(self, data: pd.DataFrame):
+      results = {}
+      for kpi_name, kpi in self.kpis.items():
+          try:
+            results[kpi_name] = eval(kpi.calculation, {}, {"df": data})
+          except Exception as e:
+              results[kpi_name] = {"error": str(e)}
+      return results
+
+class ForecastingEngine(ABC):
     @abstractmethod
-    def invoke(self, **kwargs) -> Dict[str, Any]:
-        pass
+    def predict(self, data: pd.DataFrame, **kwargs) -> pd.DataFrame:
+         pass
 
-# ---------------------- Concrete Analyzer Implementations ---------------------------
-class AdvancedEDA(DataAnalyzer):
-    """Comprehensive Exploratory Data Analysis"""
-    def invoke(self, data_key: str, **kwargs) -> Dict[str, Any]:
-        try:
-            data = st.session_state[data_key]
-            analysis = {
-                "dimensionality": {
-                    "rows": len(data),
-                    "columns": list(data.columns),
-                    "memory_usage": f"{data.memory_usage().sum() / 1e6:.2f} MB"
-                },
-                "statistical_profile": data.describe(percentiles=[.25, .5, .75]).to_dict(),
-                "temporal_analysis": {
-                    "date_ranges": {
-                        col: {
-                            "min": data[col].min(),
-                            "max": data[col].max()
-                        } for col in data.select_dtypes(include='datetime').columns
-                    }
-                },
-                "data_quality": {
-                    "missing_values": data.isnull().sum().to_dict(),
-                    "duplicates": data.duplicated().sum(),
-                    "cardinality": {
-                        col: data[col].nunique() for col in data.columns
-                    }
-                }
-            }
-            return analysis
-        except Exception as e:
-            return {"error": f"EDA Failed: {str(e)}"}
-
-class DistributionVisualizer(DataAnalyzer):
-    """Distribution visualizations"""
-    def invoke(self, data_key: str, columns: List[str], **kwargs) -> str:
-      try:
-          data = st.session_state[data_key]
-          plt.figure(figsize=(12, 6))
-          for i, col in enumerate(columns, 1):
-              plt.subplot(1, len(columns), i)
-              sns.histplot(data[col], kde=True, stat="density")
-              plt.title(f'Distribution of {col}', fontsize=10)
-              plt.xticks(fontsize=8)
-              plt.yticks(fontsize=8)
-          plt.tight_layout()
-        
-          buf = io.BytesIO()
-          plt.savefig(buf, format='png', dpi=300, bbox_inches='tight')
-          plt.close()
-          return base64.b64encode(buf.getvalue()).decode()
-      except Exception as e:
-          return f"Visualization Error: {str(e)}"
-
-class TemporalAnalyzer(DataAnalyzer):
-    """Time series analysis"""
-    def invoke(self, data_key: str, time_col: str, value_col: str, **kwargs) -> Dict[str, Any]:
-        try:
-            data = st.session_state[data_key]
-            ts_data = data.set_index(pd.to_datetime(data[time_col]))[value_col]
-            decomposition = seasonal_decompose(ts_data, period=365)
-            
-            plt.figure(figsize=(12, 8))
-            decomposition.plot()
-            plt.tight_layout()
-            
-            buf = io.BytesIO()
-            plt.savefig(buf, format='png')
-            plt.close()
-            plot_data = base64.b64encode(buf.getvalue()).decode()
-            
-            return {
-                "trend_statistics": {
-                    "stationarity": adfuller(ts_data)[1],
-                    "seasonality_strength": max(decomposition.seasonal)
-                },
-                "visualization": plot_data
-            }
-        except Exception as e:
-            return {"error": f"Temporal Analysis Failed: {str(e)}"}
-
-class HypothesisTester(DataAnalyzer):
-    """Statistical hypothesis testing"""
-    def invoke(self, data_key: str, group_col: str, value_col: str, **kwargs) -> Dict[str, Any]:
-      try:
-        data = st.session_state[data_key]
-        groups = data[group_col].unique()
-      
-        if len(groups) < 2:
-            return {"error": "Insufficient groups for comparison"}
-        
-        if len(groups) == 2:
-            group_data = [data[data[group_col] == g][value_col] for g in groups]
-            stat, p = ttest_ind(*group_data)
-            test_type = "Independent t-test"
-        else:
-          group_data = [data[data[group_col] == g][value_col] for g in groups]
-          stat, p = f_oneway(*group_data)
-          test_type = "ANOVA"
-        
-        return {
-            "test_type": test_type,
-            "test_statistic": stat,
-            "p_value": p,
-            "effect_size": {
-              "cohens_d": abs(group_data[0].mean() - group_data[1].mean())/np.sqrt(
-                    (group_data[0].var() + group_data[1].var())/2
-              ) if len(groups) == 2 else None
-            },
-            "interpretation": self.interpret_p_value(p)
-        }
-      except Exception as e:
-        return {"error": f"Hypothesis Testing Failed: {str(e)}"}
-
-    def interpret_p_value(self, p: float) -> str:
-      if p < 0.001: return "Very strong evidence against H0"
-      elif p < 0.01: return "Strong evidence against H0"
-      elif p < 0.05: return "Evidence against H0"
-      elif p < 0.1: return "Weak evidence against H0"
-      else: return "No significant evidence against H0"
-
-class LogisticRegressionTrainer(DataAnalyzer):
-    """Logistic Regression Model Trainer"""
-    def invoke(self, data_key: str, target_col: str, columns: List[str], **kwargs) -> Dict[str, Any]:
-      try:
-        data = st.session_state[data_key]
-        X = data[columns]
-        y = data[target_col]
-        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
-        model = LogisticRegression(max_iter=1000)
-        model.fit(X_train, y_train)
-        y_pred = model.predict(X_test)
-        accuracy = accuracy_score(y_test, y_pred)
-        return {
-          "model_type": "Logistic Regression",
-           "accuracy": accuracy,
-           "model_params": model.get_params()
-         }
-      except Exception as e:
-         return {"error": f"Logistic Regression Model Error: {str(e)}"}
+class SimpleForecasting(ForecastingEngine):
+  def predict(self, data: pd.DataFrame, period: int = 7, **kwargs) -> pd.DataFrame:
+      #Placeholder for actual forecasting
+      return pd.DataFrame({"forecast":[f"Forecast for the next {period} days"]})
+# ---------------------- Insights and Reporting Layer ---------------------------
+class AutomatedInsights():
+    def __init__(self):
+      self.analyses : Dict[str, DataAnalyzer] = {
+        "EDA": AdvancedEDA(),
+        "temporal": TemporalAnalyzer(),
+        "distribution": DistributionVisualizer(),
+        "hypothesis": HypothesisTester(),
+        "model": LogisticRegressionTrainer()
+      }
+
+    def generate_insights(self, data: pd.DataFrame, analysis_names: List[str], **kwargs):
+       results = {}
+       for name in analysis_names:
+           if name in self.analyses:
+             analyzer = self.analyses[name]
+             results[name] = analyzer.invoke(data=data, **kwargs)
+           else:
+               results[name] = {"error": "Analysis not found"}
+       return results
+
+class Dashboard():
+    def __init__(self):
+        self.layout: Dict[str,str] = {}
+    
+    def add_visualisation(self, vis_name: str, vis_type: str):
+        self.layout[vis_name] = vis_type
+  
+    def display_dashboard(self, data_dict: Dict[str,pd.DataFrame]):
+      st.header("Dashboard")
+      for vis_name, vis_type in self.layout.items():
+          st.subheader(vis_name)
+          if vis_type == "table":
+              if vis_name in data_dict:
+                st.table(data_dict[vis_name])
+              else:
+                st.write("Data Not Found")
+          elif vis_type == "plot":
+            if vis_name in data_dict:
+              df = data_dict[vis_name]
+              if len(df.columns) > 1:
+                fig = plt.figure()
+                sns.lineplot(data=df)
+                st.pyplot(fig)
+              else:
+                 st.write("Please have more than 1 column")
+            else:
+                 st.write("Data not found")
+class AutomatedReports():
+  def __init__(self):
+     self.report_definition: Dict[str,str] = {}
+
+  def create_report_definition(self, report_name: str, definition: str):
+       self.report_definition[report_name] = definition
+  
+  def generate_report(self, report_name: str, data:Dict[str, pd.DataFrame]):
+       if report_name not in self.report_definition:
+          return {"error":"Report name not found"}
+       st.header(f"Report : {report_name}")
+       st.write(f"Report Definition: {self.report_definition[report_name]}")
+       for df_name, df in data.items():
+         st.subheader(f"Data: {df_name}")
+         st.table(df)
 
 # ---------------------- Groq Research Agent ---------------------------
 
@@ -238,117 +277,262 @@ class GroqResearcher:
         
         except Exception as e:
             return f"Research Error: {str(e)}"
+
 # ---------------------- Main Streamlit Application ---------------------------
 def main():
-    st.set_page_config(page_title="AI Data Analysis Lab", layout="wide")
-    st.title("🧪 Advanced AI Data Analysis Laboratory")
+    st.set_page_config(page_title="AI BI Automation Platform", layout="wide")
+    st.title("🚀 AI-Powered Business Intelligence Automation Platform")
 
     # Session State
     if 'data' not in st.session_state:
-      st.session_state.data = None
+        st.session_state.data = {}  # store pd.DataFrame under a name
+    if 'data_ingestion' not in st.session_state:
+      st.session_state.data_ingestion = DataIngestion()
+    if 'data_modelling' not in st.session_state:
+      st.session_state.data_modelling = DataModelling()
+    if 'business_rules' not in st.session_state:
+      st.session_state.business_rules = BusinessRulesEngine()
+    if 'kpi_monitoring' not in st.session_state:
+       st.session_state.kpi_monitoring = KPIMonitoring()
+    if 'forecasting_engine' not in st.session_state:
+       st.session_state.forecasting_engine = SimpleForecasting()
+    if 'automated_insights' not in st.session_state:
+      st.session_state.automated_insights = AutomatedInsights()
+    if 'dashboard' not in st.session_state:
+       st.session_state.dashboard = Dashboard()
+    if 'automated_reports' not in st.session_state:
+      st.session_state.automated_reports = AutomatedReports()
     if 'researcher' not in st.session_state:
         st.session_state.researcher = GroqResearcher()
+  
 
-    # Data Upload
+    # Sidebar for Data Management
     with st.sidebar:
-        st.header("🔬 Data Management")
-        uploaded_file = st.file_uploader("Upload research dataset", type=["csv", "parquet"])
-        if uploaded_file:
-            with st.spinner("Initializing dataset..."):
+        st.header("⚙️ Data Management")
+        data_source_selection = st.selectbox("Select Data Source Type",["CSV","SQL Database"])
+        if data_source_selection == "CSV":
+           uploaded_file = st.file_uploader("Upload research dataset (CSV)", type=["csv"])
+           if uploaded_file:
+              source_name = st.text_input("Data Source Name")
+              if source_name:
                 try:
-                    st.session_state.data = pd.read_csv(uploaded_file)
-                    st.success(f"Loaded {len(st.session_state.data):,} research observations")
+                    csv_source = CSVDataSource(file_path=uploaded_file)
+                    st.session_state.data_ingestion.add_source(source_name,csv_source)
+                    st.success(f"Uploaded {uploaded_file.name}")
                 except Exception as e:
-                    st.error(f"Error loading dataset: {e}")
+                  st.error(f"Error loading dataset: {e}")
+        elif data_source_selection == "SQL Database":
+          conn_str = st.text_input("Enter connection string for SQL DB")
+          if conn_str:
+            source_name = st.text_input("Data Source Name")
+            if source_name:
+              try:
+                 sql_source = DatabaseSource(connection_string=conn_str, database_type="sql")
+                 st.session_state.data_ingestion.add_source(source_name, sql_source)
+                 st.success(f"Added SQL DB Source {source_name}")
+              except Exception as e:
+                 st.error(f"Error loading database source {e}")
 
 
-    if st.session_state.data is not None:
+        if st.button("Ingest Data"):
+           if st.session_state.data_ingestion.sources:
+               source_name_to_fetch = st.selectbox("Select Data Source to Ingest", list(st.session_state.data_ingestion.sources.keys()))
+               query = st.text_area("Optional Query to Fetch data")
+               if source_name_to_fetch:
+                    with st.spinner("Ingesting data..."):
+                      try:
+                          data = st.session_state.data_ingestion.ingest_data(source_name_to_fetch, query)
+                          st.session_state.data[source_name_to_fetch] = data
+                          st.success(f"Ingested data from {source_name_to_fetch}")
+                      except Exception as e:
+                        st.error(f"Ingestion failed: {e}")
+           else:
+             st.error("No data source added, please add data source")
+
+    if st.session_state.data:
         col1, col2 = st.columns([1, 3])
+
         with col1:
             st.subheader("Dataset Metadata")
-            st.json({
-                "Variables": list(st.session_state.data.columns),
-                "Time Range": {
-                    col: {
-                        "min": st.session_state.data[col].min(),
-                        "max": st.session_state.data[col].max()
-                    } for col in st.session_state.data.select_dtypes(include='datetime').columns
-                },
-                "Size": f"{st.session_state.data.memory_usage().sum() / 1e6:.2f} MB"
-            })
-
-        with col2:
-           analysis_tab, research_tab = st.tabs(["Automated Analysis", "Custom Research"])
-           with analysis_tab:
-               analysis_type = st.selectbox("Select Analysis Mode", [
-                  "Exploratory Data Analysis",
-                  "Temporal Pattern Analysis",
-                  "Comparative Statistics",
-                  "Distribution Analysis",
-                   "Train Logistic Regression Model"
-                ])
             
-               if analysis_type == "Exploratory Data Analysis":
-                   analyzer = AdvancedEDA()
-                   eda_result = analyzer.invoke(data_key="data")
-                   st.subheader("Data Quality Report")
-                   st.json(eda_result)
+            data_source_keys = list(st.session_state.data.keys())
+            selected_data_key = st.selectbox("Select Dataset", data_source_keys)
             
-               elif analysis_type == "Temporal Pattern Analysis":
-                    time_col = st.selectbox("Temporal Variable",
-                        st.session_state.data.select_dtypes(include='datetime').columns)
-                    value_col = st.selectbox("Analysis Variable",
-                        st.session_state.data.select_dtypes(include=np.number).columns)
-            
-                    if time_col and value_col:
-                        analyzer = TemporalAnalyzer()
-                        result = analyzer.invoke(data_key="data", time_col=time_col, value_col=value_col)
-                        if "visualization" in result:
-                            st.image(f"data:image/png;base64,{result['visualization']}")
+            if selected_data_key:
+                data = st.session_state.data[selected_data_key]
+                st.json({
+                    "Variables": list(data.columns),
+                    "Time Range": {
+                        col: {
+                            "min": data[col].min(),
+                            "max": data[col].max()
+                        } for col in data.select_dtypes(include='datetime').columns
+                    },
+                    "Size": f"{data.memory_usage().sum() / 1e6:.2f} MB"
+                })
+        with col2:
+            analysis_tab, business_logic_tab, insights_tab, reports_tab, custom_research_tab = st.tabs([
+              "Data Analysis",
+              "Business Logic",
+               "Insights",
+               "Reports",
+              "Custom Research"
+              ])
+
+            with analysis_tab:
+                if selected_data_key:
+                    analysis_type = st.selectbox("Select Analysis Mode", [
+                     "Exploratory Data Analysis",
+                     "Temporal Pattern Analysis",
+                      "Comparative Statistics",
+                      "Distribution Analysis",
+                       "Train Logistic Regression Model"
+                    ])
+                    data = st.session_state.data[selected_data_key]
+                    if analysis_type == "Exploratory Data Analysis":
+                        analyzer = AdvancedEDA()
+                        eda_result = analyzer.invoke(data=data)
+                        st.subheader("Data Quality Report")
+                        st.json(eda_result)
+
+                    elif analysis_type == "Temporal Pattern Analysis":
+                        time_col = st.selectbox("Temporal Variable",
+                            data.select_dtypes(include='datetime').columns)
+                        value_col = st.selectbox("Analysis Variable",
+                            data.select_dtypes(include=np.number).columns)
+
+                        if time_col and value_col:
+                          analyzer = TemporalAnalyzer()
+                          result = analyzer.invoke(data=data, time_col=time_col, value_col=value_col)
+                          if "visualization" in result:
+                              st.image(f"data:image/png;base64,{result['visualization']}")
+                          st.json(result)
+
+                    elif analysis_type == "Comparative Statistics":
+                        group_col = st.selectbox("Grouping Variable",
+                             data.select_dtypes(include='category').columns)
+                        value_col = st.selectbox("Metric Variable",
+                             data.select_dtypes(include=np.number).columns)
+
+                        if group_col and value_col:
+                          analyzer = HypothesisTester()
+                          result = analyzer.invoke(data=data, group_col=group_col, value_col=value_col)
+                          st.subheader("Statistical Test Results")
+                          st.json(result)
+
+                    elif analysis_type == "Distribution Analysis":
+                        num_cols = data.select_dtypes(include=np.number).columns.tolist()
+                        selected_cols = st.multiselect("Select Variables", num_cols)
+                        if selected_cols:
+                           analyzer = DistributionVisualizer()
+                           img_data = analyzer.invoke(data=data, columns=selected_cols)
+                           st.image(f"data:image/png;base64,{img_data}")
+                       
+                    elif analysis_type == "Train Logistic Regression Model":
+                       num_cols = data.select_dtypes(include=np.number).columns.tolist()
+                       target_col = st.selectbox("Select Target Variable",
+                                                   data.columns.tolist())
+                       selected_cols = st.multiselect("Select Feature Variables", num_cols)
+                       if selected_cols and target_col:
+                         analyzer = LogisticRegressionTrainer()
+                         result = analyzer.invoke(data=data, target_col=target_col, columns=selected_cols)
+                         st.subheader("Logistic Regression Model Results")
+                         st.json(result)
+            with business_logic_tab:
+              st.header("Business Logic")
+              st.subheader("Data Modelling")
+              model_name = st.text_input("Enter the name of the model")
+              
+              if model_name:
+                kpis = st.text_input("Enter KPIs (comma-separated)")
+                dimensions = st.text_input("Enter Dimensions (comma-separated)")
+                custom_calculations = st.text_area("Custom calculations (JSON format), use {'df': DataFrame}")
+                relations = st.text_area("Relations (JSON format), use {'table1': 'table2'}")
+                if st.button("Add Data Model"):
+                 try:
+                  custom_calculations_dict = None if not custom_calculations else json.loads(custom_calculations)
+                  relations_dict = None if not relations else json.loads(relations)
+                  model = DataModel(name=model_name,
+                                     kpis= [kpi.strip() for kpi in kpis.split(',')] if kpis else [],
+                                   dimensions=[dim.strip() for dim in dimensions.split(',')] if dimensions else [],
+                                   custom_calculations= custom_calculations_dict,
+                                   relations = relations_dict)
+                  st.session_state.data_modelling.add_model(model)
+                  st.success(f"Added data model {model_name}")
+                 except Exception as e:
+                  st.error(f"Error creating data model: {e}")
+
+              st.subheader("Business Rules")
+              rule_name = st.text_input("Enter Rule Name")
+              condition = st.text_area("Enter Rule Condition (use 'df' for data frame), Example df['sales'] > 100")
+              action = st.text_area("Enter Action to be Taken on Rule Match")
+              if st.button("Add Business Rule"):
+                try:
+                 rule = BusinessRule(name=rule_name, condition=condition, action=action)
+                 st.session_state.business_rules.add_rule(rule)
+                 st.success("Added Business Rule")
+                except Exception as e:
+                  st.error(f"Error in rule definition: {e}")
+                
+              st.subheader("KPI Definition")
+              kpi_name = st.text_input("Enter KPI name")
+              kpi_calculation = st.text_area("Enter KPI calculation (use 'df' for data frame), Example df['revenue'].sum()")
+              threshold = st.text_input("Enter Threshold for KPI")
+              if st.button("Add KPI"):
+                  try:
+                    threshold_value = float(threshold) if threshold else None
+                    kpi = KPI(name=kpi_name, calculation=kpi_calculation, threshold=threshold_value)
+                    st.session_state.kpi_monitoring.add_kpi(kpi)
+                    st.success(f"Added KPI {kpi_name}")
+                  except Exception as e:
+                      st.error(f"Error creating KPI: {e}")
+              if selected_data_key:
+                   data = st.session_state.data[selected_data_key]
+                   if st.button("Execute Business Rules"):
+                      with st.spinner("Executing Business Rules.."):
+                        result = st.session_state.business_rules.execute_rules(data)
                         st.json(result)
+                   if st.button("Calculate KPIs"):
+                       with st.spinner("Calculating KPIs..."):
+                         result = st.session_state.kpi_monitoring.calculate_kpis(data)
+                         st.json(result)
+
+            with insights_tab:
+              if selected_data_key:
+                  data = st.session_state.data[selected_data_key]
+                  available_analysis = ["EDA", "temporal", "distribution", "hypothesis", "model"]
+                  selected_analysis = st.multiselect("Select Analysis", available_analysis)
+                  if st.button("Generate Automated Insights"):
+                    with st.spinner("Generating Insights"):
+                        results = st.session_state.automated_insights.generate_insights(data, analysis_names=selected_analysis)
+                        st.json(results)
             
-               elif analysis_type == "Comparative Statistics":
-                    group_col = st.selectbox("Grouping Variable",
-                        st.session_state.data.select_dtypes(include='category').columns)
-                    value_col = st.selectbox("Metric Variable",
-                        st.session_state.data.select_dtypes(include=np.number).columns)
-            
-                    if group_col and value_col:
-                        analyzer = HypothesisTester()
-                        result = analyzer.invoke(data_key="data", group_col=group_col, value_col=value_col)
-                        st.subheader("Statistical Test Results")
-                        st.json(result)
-                
-               elif analysis_type == "Distribution Analysis":
-                    num_cols = st.session_state.data.select_dtypes(include=np.number).columns.tolist()
-                    selected_cols = st.multiselect("Select Variables", num_cols)
-                    if selected_cols:
-                        analyzer = DistributionVisualizer()
-                        img_data = analyzer.invoke(data_key="data", columns=selected_cols)
-                        st.image(f"data:image/png;base64,{img_data}")
-               
-               elif analysis_type == "Train Logistic Regression Model":
-                 num_cols = st.session_state.data.select_dtypes(include=np.number).columns.tolist()
-                 target_col = st.selectbox("Select Target Variable",
-                                           st.session_state.data.columns.tolist())
-                 selected_cols = st.multiselect("Select Feature Variables", num_cols)
-                 if selected_cols and target_col:
-                   analyzer = LogisticRegressionTrainer()
-                   result = analyzer.invoke(data_key="data", target_col=target_col, columns=selected_cols)
-                   st.subheader("Logistic Regression Model Results")
-                   st.json(result)
-
-           with research_tab:
-               research_query = st.text_area("Enter Research Question:", height=150,
-                   placeholder="E.g., 'What factors are most predictive of X outcome?'")
-               
-               if st.button("Execute Research"):
+            with reports_tab:
+                 st.header("Reports")
+                 report_name = st.text_input("Report Name")
+                 report_def = st.text_area("Report definition")
+                 if st.button("Create Report Definition"):
+                   st.session_state.automated_reports.create_report_definition(report_name, report_def)
+                   st.success("Report definition created")
+                 if selected_data_key:
+                   data = st.session_state.data
+                   if st.button("Generate Report"):
+                     with st.spinner("Generating Report..."):
+                       report = st.session_state.automated_reports.generate_report(report_name, data)
+
+            with custom_research_tab:
+                research_query = st.text_area("Enter Research Question:", height=150,
+                    placeholder="E.g., 'What factors are most predictive of X outcome?'")
+
+                if st.button("Execute Custom Research"):
                     with st.spinner("Conducting rigorous analysis..."):
-                      result = st.session_state.researcher.research(
-                        research_query, st.session_state.data
-                      )
-                      st.markdown("## Research Findings")
-                      st.markdown(result)
+                        if selected_data_key:
+                            data = st.session_state.data[selected_data_key]
+                            result = st.session_state.researcher.research(
+                                research_query, data
+                            )
+                            st.markdown("## Research Findings")
+                            st.markdown(result)
 
 if __name__ == "__main__":
     main()