Upload 8 files

app.py

@@ -0,0 +1,406 @@
+# app.py
+"""
+Streamlit frontend application for the Tensorus platform.
+Interacts with the FastAPI backend (api.py).
+"""
+
+import streamlit as st
+import json
+import time
+import requests # Needed for ui_utils functions if integrated
+import logging # Needed for ui_utils functions if integrated
+import torch # Needed for integrated tensor utils
+from typing import List, Dict, Any, Optional, Union, Tuple # Needed for integrated tensor utils
+
+# --- Page Configuration ---
+st.set_page_config(
+    page_title="Tensorus Platform",
+    page_icon="🧊",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# --- Configure Logging (Optional but good practice) ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- Integrated Tensor Utilities ---
+
+def _validate_tensor_data(data: List[Any], shape: List[int]):
+    """
+    Validates if the nested list structure of 'data' matches the 'shape'.
+    Raises ValueError on mismatch. (Optional validation)
+    """
+    if not shape:
+        if not isinstance(data, (int, float)): raise ValueError("Scalar tensor data must be a single number.")
+        return True
+    if not isinstance(data, list): raise ValueError(f"Data for shape {shape} must be a list.")
+    expected_len = shape[0]
+    if len(data) != expected_len: raise ValueError(f"Dimension 0 mismatch: Expected {expected_len}, got {len(data)} for shape {shape}.")
+    if len(shape) > 1:
+        for item in data: _validate_tensor_data(item, shape[1:])
+    elif len(shape) == 1:
+        if not all(isinstance(x, (int, float)) for x in data): raise ValueError("Innermost list elements must be numbers.")
+    return True
+
+def list_to_tensor(shape: List[int], dtype_str: str, data: Union[List[Any], int, float]) -> torch.Tensor:
+    """
+    Converts a Python list (potentially nested) or scalar into a PyTorch tensor
+    with the specified shape and dtype.
+    """
+    try:
+        dtype_map = {
+            'float32': torch.float32, 'float': torch.float,
+            'float64': torch.float64, 'double': torch.double,
+            'int32': torch.int32, 'int': torch.int,
+            'int64': torch.int64, 'long': torch.long,
+            'bool': torch.bool
+        }
+        torch_dtype = dtype_map.get(dtype_str.lower())
+        if torch_dtype is None: raise ValueError(f"Unsupported dtype string: {dtype_str}")
+
+        tensor = torch.tensor(data, dtype=torch_dtype)
+
+        if list(tensor.shape) != shape:
+            logger.debug(f"Initial tensor shape {list(tensor.shape)} differs from target {shape}. Attempting reshape.")
+            try:
+                tensor = tensor.reshape(shape)
+            except RuntimeError as reshape_err:
+                raise ValueError(f"Created tensor shape {list(tensor.shape)} != requested {shape} and reshape failed: {reshape_err}") from reshape_err
+
+        return tensor
+    except (TypeError, ValueError) as e:
+        logger.error(f"Error converting list to tensor: {e}. Shape: {shape}, Dtype: {dtype_str}")
+        raise ValueError(f"Failed tensor conversion: {e}") from e
+    except Exception as e:
+        logger.exception(f"Unexpected error during list_to_tensor: {e}")
+        raise ValueError(f"Unexpected tensor conversion error: {e}") from e
+
+def tensor_to_list(tensor: torch.Tensor) -> Tuple[List[int], str, List[Any]]:
+    """
+    Converts a PyTorch tensor back into its shape, dtype string, and nested list representation.
+    """
+    if not isinstance(tensor, torch.Tensor):
+        raise TypeError("Input must be a torch.Tensor")
+    shape = list(tensor.shape)
+    dtype_str = str(tensor.dtype).split('.')[-1]
+    data = tensor.tolist()
+    return shape, dtype_str, data
+
+# --- Integrated UI Utilities (from former ui_utils.py) ---
+
+# Define the base URL of your FastAPI backend
+API_BASE_URL = "http://127.0.0.1:8000" # Make sure this matches where api.py runs
+
+def get_api_status():
+    """Checks if the backend API is reachable."""
+    try:
+        response = requests.get(f"{API_BASE_URL}/", timeout=2)
+        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+        return True, response.json()
+    except requests.exceptions.RequestException as e:
+        logger.error(f"API connection error: {e}")
+        return False, {"error": str(e)}
+
+def get_agent_status():
+    """Fetches status for all agents from the backend."""
+    try:
+        response = requests.get(f"{API_BASE_URL}/agents/status", timeout=5)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error fetching agent status: {e}")
+        return None
+
+def start_agent(agent_id: str):
+    """Sends a request to start an agent."""
+    try:
+        response = requests.post(f"{API_BASE_URL}/agents/{agent_id}/start", timeout=5)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error starting agent {agent_id}: {e}")
+        return {"success": False, "message": str(e)}
+
+def stop_agent(agent_id: str):
+    """Sends a request to stop an agent."""
+    try:
+        response = requests.post(f"{API_BASE_URL}/agents/{agent_id}/stop", timeout=5)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error stopping agent {agent_id}: {e}")
+        return {"success": False, "message": str(e)}
+
+def configure_agent(agent_id: str, config: dict):
+    """Sends a request to configure an agent."""
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/agents/{agent_id}/configure",
+            json={"config": config},
+            timeout=5
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error configuring agent {agent_id}: {e}")
+        return {"success": False, "message": str(e)}
+
+def post_nql_query(query: str):
+    """Sends an NQL query to the backend."""
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/chat/query",
+            json={"query": query},
+            timeout=15 # Allow more time for potentially complex queries
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error posting NQL query: {e}")
+        return {"query": query, "response_text": "Error connecting to backend.", "error": str(e)}
+
+def get_datasets():
+    """Fetches the list of available datasets."""
+    try:
+        response = requests.get(f"{API_BASE_URL}/explorer/datasets", timeout=5)
+        response.raise_for_status()
+        data = response.json()
+        return data.get("datasets", [])
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error fetching datasets: {e}")
+        return [] # Return empty list on error
+
+def get_dataset_preview(dataset_name: str, limit: int = 5):
+    """Fetches preview data for a specific dataset."""
+    try:
+        response = requests.get(f"{API_BASE_URL}/explorer/dataset/{dataset_name}/preview?limit={limit}", timeout=10)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error fetching preview for {dataset_name}: {e}")
+        return None
+
+def operate_explorer(dataset: str, operation: str, index: int, params: dict):
+    """Sends an operation request to the data explorer."""
+    payload = {
+        "dataset": dataset,
+        "operation": operation,
+        "tensor_index": index,
+        "params": params
+    }
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/explorer/operate",
+            json=payload,
+            timeout=15 # Allow time for computation
+        )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error performing operation '{operation}' on {dataset}: {e}")
+        return {"success": False, "metadata": {"error": str(e)}, "result_data": None}
+
+
+# --- Initialize Session State ---
+if 'agent_status' not in st.session_state:
+    st.session_state.agent_status = None
+if 'datasets' not in st.session_state:
+    st.session_state.datasets = []
+if 'selected_dataset' not in st.session_state:
+    st.session_state.selected_dataset = None
+if 'dataset_preview' not in st.session_state:
+    st.session_state.dataset_preview = None
+if 'explorer_result' not in st.session_state:
+    st.session_state.explorer_result = None
+if 'nql_response' not in st.session_state:
+    st.session_state.nql_response = None
+
+
+# --- Sidebar ---
+with st.sidebar:
+    st.title("Tensorus Control")
+    st.markdown("---")
+
+    # API Status Check
+    st.subheader("API Status")
+    api_ok, api_info = get_api_status() # Use integrated function
+    if api_ok:
+        st.success(f"Connected to API v{api_info.get('version', 'N/A')}")
+    else:
+        st.error(f"API Connection Failed: {api_info.get('error', 'Unknown error')}")
+        st.warning("Ensure the backend (`uvicorn api:app ...`) is running.")
+        st.stop()
+
+    st.markdown("---")
+    # Navigation
+    app_mode = st.radio(
+        "Select Feature",
+        ("Dashboard", "Agent Control", "NQL Chat", "Data Explorer")
+    )
+    st.markdown("---")
+
+
+# --- Main Page Content ---
+
+if app_mode == "Dashboard":
+    st.title("📊 Operations Dashboard")
+    st.warning("Live WebSocket dashboard view is best accessed directly via the backend's `/dashboard` HTML page or a dedicated JS frontend. This is a simplified view.")
+    st.markdown(f"Access the basic live dashboard here.", unsafe_allow_html=True) # Link to backend dashboard
+    st.info("This Streamlit view doesn't currently support live WebSocket updates.")
+
+
+elif app_mode == "Agent Control":
+    st.title("🤖 Agent Control Panel")
+
+    if st.button("Refresh Agent Status"):
+        st.session_state.agent_status = get_agent_status() # Use integrated function
+
+    if st.session_state.agent_status:
+        agents = st.session_state.agent_status
+        agent_ids = list(agents.keys())
+
+        if not agent_ids:
+            st.warning("No agents reported by the backend.")
+        else:
+            selected_agent_id = st.selectbox("Select Agent", agent_ids)
+
+            if selected_agent_id:
+                agent_info = agents[selected_agent_id]
+                st.subheader(f"Agent: {agent_info.get('name', selected_agent_id)}")
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Status", "Running" if agent_info.get('running') else "Stopped")
+                    st.write("**Configuration:**")
+                    st.json(agent_info.get('config', {}))
+                with col2:
+                    st.write("**Recent Logs:**")
+                    st.code('\n'.join(agent_info.get('logs', [])), language='log')
+
+                st.write("**Actions:**")
+                btn_col1, btn_col2, btn_col3 = st.columns(3)
+                with btn_col1:
+                    if st.button("Start Agent", key=f"start_{selected_agent_id}", disabled=agent_info.get('running')):
+                        result = start_agent(selected_agent_id) # Use integrated function
+                        st.toast(result.get("message", "Request sent."))
+                        st.session_state.agent_status = get_agent_status() # Refresh status
+                        st.rerun()
+                with btn_col2:
+                    if st.button("Stop Agent", key=f"stop_{selected_agent_id}", disabled=not agent_info.get('running')):
+                        result = stop_agent(selected_agent_id) # Use integrated function
+                        st.toast(result.get("message", "Request sent."))
+                        st.session_state.agent_status = get_agent_status() # Refresh status
+                        st.rerun()
+
+    else:
+        st.info("Click 'Refresh Agent Status' to load agent information.")
+
+
+elif app_mode == "NQL Chat":
+    st.title("💬 Natural Language Query (NQL)")
+    st.info("Ask questions about the data stored in Tensorus (e.g., 'show me tensors from rl_experiences', 'count records in sample_data').")
+
+    user_query = st.text_input("Enter your query:", key="nql_query_input")
+
+    if st.button("Submit Query", key="nql_submit"):
+        if user_query:
+            with st.spinner("Processing query..."):
+                st.session_state.nql_response = post_nql_query(user_query) # Use integrated function
+        else:
+            st.warning("Please enter a query.")
+
+    if st.session_state.nql_response:
+        resp = st.session_state.nql_response
+        st.markdown("---")
+        st.write(f"**Query:** {resp.get('query')}")
+        if resp.get("error"):
+            st.error(f"Error: {resp.get('error')}")
+        else:
+            st.success(f"**Response:** {resp.get('response_text')}")
+            if resp.get("results"):
+                st.write("**Results Preview:**")
+                st.json(resp.get("results"))
+        st.session_state.nql_response = None
+
+
+elif app_mode == "Data Explorer":
+    st.title("🔍 Data Explorer")
+
+    if not st.session_state.datasets or st.button("Refresh Datasets"):
+        st.session_state.datasets = get_datasets() # Use integrated function
+
+    if not st.session_state.datasets:
+        st.warning("No datasets found or failed to fetch from backend.")
+    else:
+        st.session_state.selected_dataset = st.selectbox(
+            "Select Dataset",
+            st.session_state.datasets,
+            index=st.session_state.datasets.index(st.session_state.selected_dataset) if st.session_state.selected_dataset in st.session_state.datasets else 0
+        )
+
+        if st.session_state.selected_dataset:
+            if st.button("Show Preview", key="preview_btn"):
+                with st.spinner(f"Fetching preview for {st.session_state.selected_dataset}..."):
+                    st.session_state.dataset_preview = get_dataset_preview(st.session_state.selected_dataset) # Use integrated function
+
+            if st.session_state.dataset_preview:
+                st.subheader(f"Preview: {st.session_state.dataset_preview.get('dataset')}")
+                st.write(f"Total Records: {st.session_state.dataset_preview.get('record_count')}")
+                st.dataframe(st.session_state.dataset_preview.get('preview', []))
+                st.markdown("---")
+
+            st.subheader("Perform Operation")
+            record_count = st.session_state.dataset_preview.get('record_count', 1) if st.session_state.dataset_preview else 1
+            tensor_index = st.number_input("Select Tensor Index", min_value=0, max_value=max(0, record_count - 1), value=0, step=1)
+
+            operations = ["info", "head", "slice", "sum", "mean", "reshape", "transpose"]
+            selected_op = st.selectbox("Select Operation", operations)
+
+            params = {}
+            # Dynamic parameter inputs
+            if selected_op == "head":
+                params['count'] = st.number_input("Count", min_value=1, value=5, step=1)
+            elif selected_op == "slice":
+                params['dim'] = st.number_input("Dimension (dim)", value=0, step=1)
+                params['start'] = st.number_input("Start Index", value=0, step=1)
+                params['end'] = st.number_input("End Index (optional)", value=None, step=1, format="%d")
+                params['step'] = st.number_input("Step (optional)", value=None, step=1, format="%d")
+            elif selected_op in ["sum", "mean"]:
+                dim_input = st.text_input("Dimension(s) (optional, e.g., 0 or 0,1)")
+                if dim_input:
+                    try: params['dim'] = [int(x.strip()) for x in dim_input.split(',')] if ',' in dim_input else int(dim_input)
+                    except ValueError: st.warning("Invalid dimension format.")
+                params['keepdim'] = st.checkbox("Keep Dimensions (keepdim)", value=False)
+            elif selected_op == "reshape":
+                shape_input = st.text_input("Target Shape (comma-separated, e.g., 2,3,5)")
+                if shape_input:
+                    try: params['shape'] = [int(x.strip()) for x in shape_input.split(',')]
+                    except ValueError: st.warning("Invalid shape format.")
+            elif selected_op == "transpose":
+                params['dim0'] = st.number_input("Dimension 0", value=0, step=1)
+                params['dim1'] = st.number_input("Dimension 1", value=1, step=1)
+
+            if st.button("Run Operation", key="run_op_btn"):
+                valid_request = True
+                if selected_op == "reshape" and not params.get('shape'):
+                    st.error("Target Shape is required for reshape.")
+                    valid_request = False
+
+                if valid_request:
+                    with st.spinner(f"Running {selected_op} on {st.session_state.selected_dataset}[{tensor_index}]..."):
+                        st.session_state.explorer_result = operate_explorer( # Use integrated function
+                            st.session_state.selected_dataset,
+                            selected_op,
+                            tensor_index,
+                            params
+                        )
+
+            if st.session_state.explorer_result:
+                st.markdown("---")
+                st.subheader("Operation Result")
+                st.write("**Metadata:**")
+                st.json(st.session_state.explorer_result.get("metadata", {}))
+                st.write("**Result Data:**")
+                st.json(st.session_state.explorer_result.get("result_data", "No data returned."))
+

pages/1_📊_Dashboard.py

@@ -0,0 +1,125 @@
+# pages/1_📊_Dashboard.py (Modifications for Step 3)
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import time
+# Updated imports to use API-backed functions
+from ui_utils import get_dashboard_metrics, list_all_agents, get_agent_status
+
+st.set_page_config(page_title="Tensorus Dashboard", layout="wide")
+
+st.title("📊 Operations Dashboard")
+st.caption("Overview of Tensorus datasets and agent activity from API.")
+
+# --- Fetch Data ---
+# Use st.cache_data for API calls that don't need constant updates
+# or manage refresh manually. For simplicity, call directly on rerun/button click.
+metrics_data = None
+agent_list = None # Fetch full agent list for detailed status display
+
+# Button to force refresh
+if st.button("🔄 Refresh Dashboard Data"):
+    # Clear previous cache if any or just proceed to refetch
+    metrics_data = get_dashboard_metrics()
+    agent_list = list_all_agents()
+    st.session_state['dashboard_metrics'] = metrics_data # Store in session state
+    st.session_state['dashboard_agents'] = agent_list
+    st.rerun() # Rerun the script to reflect fetched data
+else:
+    # Try to load from session state or fetch if not present
+    if 'dashboard_metrics' not in st.session_state:
+         st.session_state['dashboard_metrics'] = get_dashboard_metrics()
+    if 'dashboard_agents' not in st.session_state:
+         st.session_state['dashboard_agents'] = list_all_agents()
+
+    metrics_data = st.session_state['dashboard_metrics']
+    agent_list = st.session_state['dashboard_agents']
+
+
+# --- Display Metrics ---
+st.subheader("System Metrics")
+if metrics_data:
+    col1, col2, col3 = st.columns(3)
+    col1.metric("Total Datasets", metrics_data.get('dataset_count', 'N/A'))
+    col2.metric("Total Records (Est.)", f"{metrics_data.get('total_records_est', 0):,}")
+    # Agent status summary from metrics
+    agent_summary = metrics_data.get('agent_status_summary', {})
+    running_agents = agent_summary.get('running', 0) + agent_summary.get('starting', 0)
+    col3.metric("Running Agents", running_agents)
+
+    st.divider()
+
+    # --- Performance Metrics Row ---
+    st.subheader("Performance Indicators (Simulated)")
+    pcol1, pcol2, pcol3, pcol4 = st.columns(4)
+    pcol1.metric("Ingestion Rate (rec/s)", f"{metrics_data.get('data_ingestion_rate', 0.0):.1f}")
+    pcol2.metric("Avg Query Latency (ms)", f"{metrics_data.get('avg_query_latency_ms', 0.0):.1f}")
+    pcol3.metric("Latest RL Reward", f"{metrics_data.get('rl_latest_reward', 'N/A')}")
+    pcol4.metric("Best AutoML Score", f"{metrics_data.get('automl_best_score', 'N/A')}")
+
+else:
+    st.warning("Could not fetch dashboard metrics from the API.")
+
+st.divider()
+
+# --- Agent Status Details ---
+st.subheader("Agent Status")
+if agent_list:
+    num_agents = len(agent_list)
+    cols = st.columns(max(1, num_agents)) # Create columns for agents
+
+    for i, agent_info in enumerate(agent_list):
+        agent_id = agent_info.get('id')
+        with cols[i % len(cols)]: # Distribute agents into columns
+            with st.container(border=True):
+                st.markdown(f"**{agent_info.get('name', 'Unknown Agent')}** (`{agent_id}`)")
+                # Fetch detailed status for more info if needed, or use basic status from list
+                # status_details = get_agent_status(agent_id) # Can make page slower
+                status = agent_info.get('status', 'unknown')
+                status_color = "green" if status in ["running", "starting"] else ("orange" if status in ["stopping"] else ("red" if status in ["error"] else "grey"))
+                st.markdown(f"Status: :{status_color}[**{status.upper()}**]")
+
+                # Display config from the list info
+                with st.expander("Config"):
+                    st.json(agent_info.get('config', {}), expanded=False)
+else:
+    st.warning("Could not fetch agent list from the API.")
+
+st.divider()
+
+# --- Performance Monitoring Chart (Using simulated data from metrics for now) ---
+st.subheader("Performance Monitoring (Placeholder Graph)")
+if metrics_data:
+    # Create some fake historical data for plotting based on current metrics
+    history_len = 20
+    # Use session state to persist some history for smoother simulation
+    if 'sim_history' not in st.session_state:
+        st.session_state['sim_history'] = pd.DataFrame({
+            'Ingestion Rate': np.random.rand(history_len) * metrics_data.get('data_ingestion_rate', 10),
+            'Query Latency': np.random.rand(history_len) * metrics_data.get('avg_query_latency_ms', 100),
+            'RL Reward': np.random.randn(history_len) * 5 + (metrics_data.get('rl_latest_reward', 0) or 0)
+        })
+
+    # Update history with latest point
+    latest_data = pd.DataFrame({
+         'Ingestion Rate': [metrics_data.get('data_ingestion_rate', 0.0)],
+         'Query Latency': [metrics_data.get('avg_query_latency_ms', 0.0)],
+         'RL Reward': [metrics_data.get('rl_latest_reward', 0) or 0] # Handle None
+    })
+    st.session_state['sim_history'] = pd.concat([st.session_state['sim_history'].iloc[1:], latest_data], ignore_index=True)
+
+
+    # Use Plotly for better interactivity
+    try:
+        fig = px.line(st.session_state['sim_history'], title="Simulated Performance Metrics Over Time")
+        fig.update_layout(legend_title_text='Metrics')
+        st.plotly_chart(fig, use_container_width=True)
+    except Exception as e:
+        st.warning(f"Could not display performance chart: {e}")
+
+else:
+     st.info("Performance metrics unavailable.")
+
+st.caption(f"Dashboard data timestamp: {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(metrics_data.get('timestamp', time.time())) if metrics_data else time.time())}")

pages/2_🕹️_Control_Panel.py

@@ -0,0 +1,112 @@
+# pages/2_🕹️_Control_Panel.py (Modifications for Step 3)
+
+import streamlit as st
+import time
+# Use the updated API-backed functions
+from ui_utils import list_all_agents, get_agent_status, get_agent_logs, start_agent, stop_agent
+
+st.set_page_config(page_title="Agent Control Panel", layout="wide")
+
+st.title("🕹️ Multi-Agent Control Panel")
+st.caption("Manage and monitor Tensorus agents via API.")
+
+# Fetch agent list from API
+agent_list = list_all_agents()
+
+if not agent_list:
+    st.error("Could not fetch agent list from API. Please ensure the backend is running and reachable.")
+    st.stop()
+
+# Create a mapping from name to ID for easier selection
+# Handle potential duplicate names if necessary, though IDs should be unique
+agent_options = {agent['name']: agent['id'] for agent in agent_list}
+# Add ID to name if names aren't unique (optional robustness)
+# agent_options = {f"{agent['name']} ({agent['id']})": agent['id'] for agent in agent_list}
+
+
+selected_agent_name = st.selectbox("Select Agent:", options=agent_options.keys())
+
+if selected_agent_name:
+    selected_agent_id = agent_options[selected_agent_name]
+    st.divider()
+    st.subheader(f"Control: {selected_agent_name} (`{selected_agent_id}`)")
+
+    # Use session state to store fetched status and logs for the selected agent
+    # This avoids refetching constantly unless a refresh is triggered
+    agent_state_key = f"agent_status_{selected_agent_id}"
+    agent_logs_key = f"agent_logs_{selected_agent_id}"
+
+    # Button to force refresh status and logs
+    if st.button(f"🔄 Refresh Status & Logs##{selected_agent_id}"): # Unique key per agent
+        st.session_state[agent_state_key] = get_agent_status(selected_agent_id)
+        st.session_state[agent_logs_key] = get_agent_logs(selected_agent_id)
+        st.rerun() # Rerun to display refreshed data
+
+    # Fetch status if not in session state or refresh button wasn't just clicked
+    if agent_state_key not in st.session_state:
+        st.session_state[agent_state_key] = get_agent_status(selected_agent_id)
+
+    status_info = st.session_state[agent_state_key]
+
+    if status_info:
+        status = status_info.get('status', 'unknown')
+        status_color = "green" if status in ["running", "starting"] else ("orange" if status in ["stopping"] else ("red" if status in ["error"] else "grey"))
+        st.markdown(f"Current Status: :{status_color}[**{status.upper()}**]")
+        last_log_ts = status_info.get('last_log_timestamp')
+        if last_log_ts:
+            st.caption(f"Last Log Entry (approx.): {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(last_log_ts))}")
+    else:
+        st.error(f"Could not retrieve status for agent '{selected_agent_name}'.")
+
+    # Control Buttons (Now call API functions)
+    col1, col2, col3 = st.columns([1, 1, 5])
+    is_running = status_info and status_info.get('status') == 'running'
+    is_stopped = status_info and status_info.get('status') == 'stopped'
+
+    with col1:
+        start_disabled = not is_stopped # Disable if not stopped
+        if st.button("▶️ Start", key=f"start_{selected_agent_id}", disabled=start_disabled):
+            if start_agent(selected_agent_id): # API call returns success/fail
+                # Trigger refresh after short delay to allow backend state change (optimistic)
+                time.sleep(1.0)
+                # Clear state cache and rerun
+                if agent_state_key in st.session_state: del st.session_state[agent_state_key]
+                if agent_logs_key in st.session_state: del st.session_state[agent_logs_key]
+                st.rerun()
+    with col2:
+        stop_disabled = not is_running # Disable if not running
+        if st.button("⏹️ Stop", key=f"stop_{selected_agent_id}", disabled=stop_disabled):
+            if stop_agent(selected_agent_id): # API call returns success/fail
+                time.sleep(1.0)
+                if agent_state_key in st.session_state: del st.session_state[agent_state_key]
+                if agent_logs_key in st.session_state: del st.session_state[agent_logs_key]
+                st.rerun()
+
+    st.divider()
+
+    # Configuration & Logs
+    tab1, tab2 = st.tabs(["Configuration", "Logs"])
+
+    with tab1:
+        if status_info and 'config' in status_info:
+            st.write("Current configuration:")
+            st.json(status_info['config'])
+            # TODO: Implement configuration editing via API
+            st.button("✏️ Edit Configuration (Placeholder)", disabled=True)
+        else:
+            st.warning("Configuration not available.")
+
+    with tab2:
+        st.write("Recent logs (fetched from API):")
+        # Fetch logs if not in session state
+        if agent_logs_key not in st.session_state:
+            st.session_state[agent_logs_key] = get_agent_logs(selected_agent_id)
+
+        logs = st.session_state[agent_logs_key]
+        if logs is not None:
+            st.code("\n".join(logs), language="log")
+        else:
+            st.error("Could not retrieve logs.")
+
+else:
+    st.info("Select an agent from the dropdown above.")

pages/3_💬_NQL_Chatbot.py

@@ -0,0 +1,93 @@
+# pages/3_💬_NQL_Chatbot.py
+
+import streamlit as st
+from ui_utils import execute_nql_query
+
+st.set_page_config(page_title="NQL Chatbot", layout="wide")
+
+st.title("💬 Natural Query Language (NQL) Chatbot")
+st.caption("Query Tensorus datasets using natural language.")
+st.info("Backend uses Regex-based NQL Agent. LLM integration is future work.")
+
+# Initialize chat history
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# Display chat messages from history on app rerun
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+        if "results" in message and message["results"]:
+            st.dataframe(message["results"], use_container_width=True) # Display results as dataframe
+        elif "error" in message:
+            st.error(message["error"])
+
+
+# React to user input
+if prompt := st.chat_input("Enter your query (e.g., 'get all data from my_dataset')"):
+    # Display user message in chat message container
+    st.chat_message("user").markdown(prompt)
+    # Add user message to chat history
+    st.session_state.messages.append({"role": "user", "content": prompt})
+
+    # Get assistant response from NQL Agent API
+    with st.spinner("Processing query..."):
+        nql_response = execute_nql_query(prompt)
+
+        response_content = ""
+        results_df = None
+        error_msg = None
+
+        if nql_response:
+            response_content = nql_response.get("message", "Error processing response.")
+            if nql_response.get("success"):
+                results_list = nql_response.get("results")
+                if results_list:
+                    # Convert results list (containing dicts with 'metadata', 'shape', etc.) to DataFrame
+                    # Extract relevant fields for display
+                    display_data = []
+                    for res in results_list:
+                        row = {
+                            "record_id": res["metadata"].get("record_id"),
+                            "shape": str(res.get("shape")), # Convert shape list to string
+                            "dtype": res.get("dtype"),
+                            **res["metadata"] # Flatten metadata into columns
+                        }
+                         # Remove potentially large 'tensor' data from direct display
+                        row.pop('tensor', None)
+                        # Avoid duplicate metadata keys if also present at top level
+                        row.pop('shape', None)
+                        row.pop('dtype', None)
+                        row.pop('record_id', None)
+                        display_data.append(row)
+
+                    if display_data:
+                         results_df = pd.DataFrame(display_data)
+
+                # Augment message if results found
+                count = nql_response.get("count")
+                if count is not None:
+                    response_content += f" Found {count} record(s)."
+
+            else:
+                # NQL agent indicated failure (parsing or execution)
+                error_msg = response_content # Use the message as the error
+
+        else:
+            # API call itself failed (connection error, etc.)
+            response_content = "Failed to get response from the NQL agent."
+            error_msg = response_content
+
+    # Display assistant response in chat message container
+    message_data = {"role": "assistant", "content": response_content}
+    with st.chat_message("assistant"):
+        st.markdown(response_content)
+        if results_df is not None:
+             st.dataframe(results_df, use_container_width=True)
+             message_data["results"] = results_df # Store for history display if needed (might be large)
+        elif error_msg:
+             st.error(error_msg)
+             message_data["error"] = error_msg
+
+    # Add assistant response to chat history
+    st.session_state.messages.append(message_data)

pages/4_🔍_Data_Explorer.py

@@ -0,0 +1,148 @@
+# pages/4_explorador_Data_Explorer.py
+
+import streamlit as st
+import pandas as pd
+import plotly.express as px
+from ui_utils import list_datasets, fetch_dataset_data
+import torch # Needed if we want to recreate tensors for inspection/plotting
+
+st.set_page_config(page_title="Data Explorer", layout="wide")
+
+st.title("🔍 Interactive Data Explorer")
+st.caption("Browse, filter, and visualize Tensorus datasets.")
+
+# --- Dataset Selection ---
+datasets = list_datasets()
+if not datasets:
+    st.warning("No datasets found or API connection failed. Cannot explore data.")
+    st.stop() # Stop execution if no datasets
+
+selected_dataset = st.selectbox("Select Dataset:", datasets)
+
+# --- Data Fetching & Filtering ---
+if selected_dataset:
+    st.subheader(f"Exploring: {selected_dataset}")
+
+    # Fetch data (limited records for UI)
+    # TODO: Implement server-side sampling/pagination via API for large datasets
+    MAX_RECORDS_DISPLAY = 100
+    records = fetch_dataset_data(selected_dataset, max_records=MAX_RECORDS_DISPLAY)
+
+    if records is None:
+        st.error("Failed to fetch data for the selected dataset.")
+        st.stop()
+    elif not records:
+        st.info("Selected dataset is empty.")
+        st.stop()
+
+    st.info(f"Displaying first {len(records)} records out of potentially more.")
+
+    # Create DataFrame from metadata for filtering/display
+    metadata_list = [r['metadata'] for r in records]
+    df_meta = pd.DataFrame(metadata_list)
+
+    # --- Metadata Filtering UI ---
+    st.sidebar.header("Filter by Metadata")
+    filter_cols = st.sidebar.multiselect("Select metadata columns to filter:", options=df_meta.columns.tolist())
+
+    filtered_df = df_meta.copy()
+    for col in filter_cols:
+        unique_values = filtered_df[col].dropna().unique().tolist()
+        if pd.api.types.is_numeric_dtype(filtered_df[col]):
+            # Numeric filter (slider)
+            min_val, max_val = float(filtered_df[col].min()), float(filtered_df[col].max())
+            if min_val < max_val:
+                selected_range = st.sidebar.slider(f"Filter {col}:", min_val, max_val, (min_val, max_val))
+                filtered_df = filtered_df[filtered_df[col].between(selected_range[0], selected_range[1])]
+            else:
+                st.sidebar.caption(f"{col}: Single numeric value ({min_val}), no range filter.")
+
+        elif len(unique_values) > 0 and len(unique_values) <= 20: # Limit dropdown options
+            # Categorical filter (multiselect)
+             selected_values = st.sidebar.multiselect(f"Filter {col}:", options=unique_values, default=unique_values)
+             if selected_values: # Only filter if some values are selected
+                  filtered_df = filtered_df[filtered_df[col].isin(selected_values)]
+             else: # If user deselects everything, show nothing
+                  filtered_df = filtered_df[filtered_df[col].isnull()] # Hack to get empty DF matching columns
+
+        else:
+            st.sidebar.text_input(f"Filter {col} (Text contains):", key=f"text_{col}")
+            search_term = st.session_state.get(f"text_{col}", "").lower()
+            if search_term:
+                # Ensure column is string type before using .str.contains
+                filtered_df = filtered_df[filtered_df[col].astype(str).str.lower().str.contains(search_term, na=False)]
+
+
+    st.divider()
+    st.subheader("Filtered Data View")
+    st.write(f"{len(filtered_df)} records matching filters.")
+    st.dataframe(filtered_df, use_container_width=True)
+
+    # --- Tensor Preview & Visualization ---
+    st.divider()
+    st.subheader("Tensor Preview")
+
+    if not filtered_df.empty:
+        # Allow selecting a record ID from the filtered results
+        record_ids = filtered_df['record_id'].tolist()
+        selected_record_id = st.selectbox("Select Record ID to Preview Tensor:", record_ids)
+
+        if selected_record_id:
+            # Find the full record data corresponding to the selected ID
+            selected_record = next((r for r in records if r['metadata'].get('record_id') == selected_record_id), None)
+
+            if selected_record:
+                st.write("Metadata:")
+                st.json(selected_record['metadata'])
+
+                shape = selected_record.get("shape")
+                dtype = selected_record.get("dtype")
+                data_list = selected_record.get("data")
+
+                st.write(f"Tensor Info: Shape={shape}, Dtype={dtype}")
+
+                try:
+                     # Recreate tensor for potential plotting/display
+                     # Be careful with large tensors in Streamlit UI!
+                     # We might only want to show info or small slices.
+                     if shape and dtype and data_list is not None:
+                          tensor = torch.tensor(data_list, dtype=getattr(torch, dtype, torch.float32)) # Use getattr for dtype
+                          st.write("Tensor Data (first few elements):")
+                          st.code(f"{tensor.flatten()[:10].numpy()}...") # Show flattened start
+
+                          # --- Simple Visualizations ---
+                          if tensor.ndim == 1 and tensor.numel() > 1:
+                               st.line_chart(tensor.numpy())
+                          elif tensor.ndim == 2 and tensor.shape[0] > 1 and tensor.shape[1] > 1 :
+                               # Simple heatmap using plotly (requires plotly)
+                               try:
+                                   fig = px.imshow(tensor.numpy(), title="Tensor Heatmap", aspect="auto")
+                                   st.plotly_chart(fig, use_container_width=True)
+                               except Exception as plot_err:
+                                   st.warning(f"Could not generate heatmap: {plot_err}")
+                          elif tensor.ndim == 3 and tensor.shape[0] in [1, 3]: # Basic image check (C, H, W) or (1, H, W)
+                               try:
+                                   # Permute if needed (e.g., C, H, W -> H, W, C for display)
+                                   if tensor.shape[0] in [1, 3]:
+                                       display_tensor = tensor.permute(1, 2, 0).squeeze() # H, W, C or H, W
+                                       # Clamp/normalize data to display range [0, 1] or [0, 255] - basic attempt
+                                       display_tensor = (display_tensor - display_tensor.min()) / (display_tensor.max() - display_tensor.min() + 1e-6)
+                                       st.image(display_tensor.numpy(), caption="Tensor as Image (Attempted)", use_column_width=True)
+                               except ImportError:
+                                    st.warning("Pillow needed for image display (`pip install Pillow`)")
+                               except Exception as img_err:
+                                    st.warning(f"Could not display tensor as image: {img_err}")
+                          else:
+                               st.info("No specific visualization available for this tensor shape/dimension.")
+
+                     else:
+                          st.warning("Tensor data, shape, or dtype missing in the record.")
+
+                except Exception as tensor_err:
+                    st.error(f"Error processing tensor data for preview: {tensor_err}")
+            else:
+                 st.warning("Selected record details not found (this shouldn't happen).")
+        else:
+            st.info("Select a record ID above to preview its tensor.")
+    else:
+        st.info("No records match the current filters.")

pages/5_🚀_API_Playground.py

@@ -0,0 +1,57 @@
+# pages/5_🚀_API_Playground.py
+
+import streamlit as st
+import streamlit.components.v1 as components
+from ui_utils import TENSORUS_API_URL, get_api_status # Import base URL and status check
+
+st.set_page_config(page_title="API Playground", layout="wide")
+
+st.title("🚀 API Playground & Documentation Hub")
+st.caption("Explore and interact with the Tensorus REST API.")
+
+# Check if API is running
+api_running = get_api_status()
+
+if not api_running:
+    st.error(
+        f"The Tensorus API backend does not seem to be running at {TENSORUS_API_URL}. "
+        "Please start the backend (`uvicorn api:app --reload`) to use the API Playground."
+    )
+    st.stop() # Stop execution if API is not available
+else:
+    st.success(f"Connected to API backend at {TENSORUS_API_URL}")
+
+st.markdown(
+    f"""
+    This section provides live, interactive documentation for the Tensorus API,
+    powered by FastAPI's OpenAPI integration. You can explore endpoints,
+    view schemas, and even try out API calls directly in your browser.
+
+    * **Swagger UI:** A graphical interface for exploring and testing API endpoints.
+    * **ReDoc:** Alternative documentation format, often preferred for reading.
+
+    Select a view below:
+    """
+)
+
+# Use tabs to embed Swagger and ReDoc
+tab1, tab2 = st.tabs(["Swagger UI", "ReDoc"])
+
+# Construct the documentation URLs based on the API base URL
+swagger_url = f"{TENSORUS_API_URL}/docs"
+redoc_url = f"{TENSORUS_API_URL}/redoc"
+
+with tab1:
+    st.subheader("Swagger UI")
+    st.markdown(f"Explore the API interactively. [Open in new tab]({swagger_url})")
+    # Embed Swagger UI using an iframe
+    components.iframe(swagger_url, height=800, scrolling=True)
+
+with tab2:
+    st.subheader("ReDoc")
+    st.markdown(f"View the API documentation. [Open in new tab]({redoc_url})")
+    # Embed ReDoc using an iframe
+    components.iframe(redoc_url, height=800, scrolling=True)
+
+st.divider()
+st.caption("Note: Ensure the Tensorus API backend is running to interact with the playground.")

requirements.txt

@@ -0,0 +1,28 @@
+# requirements.txt
+# Updated: 2025-04-08
+
+# --- Core Tensor and Numerics ---
+torch>=1.13.0
+numpy>=1.21.0
+
+# --- Agent Specific Dependencies ---
+# For Ingestion Agent image processing example
+Pillow>=9.0.0
+
+# --- API Layer Dependencies ---
+fastapi>=0.90.0
+# Lock Pydantic < 2.0 for broad FastAPI compatibility, adjust if using newer FastAPI explicitly with Pydantic v2
+pydantic>=1.10.0,<2.0.0
+# ASGI Server (standard includes extras like watchfiles for reload)
+uvicorn[standard]>=0.20.0
+# Optional: Needed if using FastAPI file uploads via forms
+# python-multipart>=0.0.5
+
+# --- Streamlit UI Dependencies ---
+streamlit>=1.25.0
+# For calling the FastAPI backend from the Streamlit UI
+requests>=2.28.0
+# For plotting in the Streamlit UI (Dashboard, Data Explorer)
+plotly>=5.10.0
+# Optional: For plotting example in rl_agent.py
+matplotlib>=3.5.0

ui_utils.py

@@ -0,0 +1,214 @@
+# ui_utils.py (Modifications for Step 3)
+"""Utility functions for the Tensorus Streamlit UI, now using API calls."""
+
+import requests
+import streamlit as st
+import logging
+from typing import List, Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# --- Configuration ---
+TENSORUS_API_URL = "http://127.0.0.1:8000" # Ensure FastAPI runs here
+
+# --- API Interaction Functions ---
+
+def get_api_status() -> bool:
+    """Checks if the Tensorus API is reachable."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/", timeout=2)
+        return response.status_code == 200
+    except requests.exceptions.ConnectionError:
+        return False
+    except Exception as e:
+        logger.error(f"Error checking API status: {e}")
+        return False
+
+def list_datasets() -> Optional[List[str]]:
+    """Fetches the list of dataset names from the API."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/datasets")
+        response.raise_for_status()
+        data = response.json()
+        if data.get("success"):
+            return data.get("data", [])
+        else:
+            st.error(f"API Error listing datasets: {data.get('message')}")
+            return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error listing datasets: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error listing datasets: {e}")
+        logger.exception("Unexpected error in list_datasets")
+        return None
+
+def fetch_dataset_data(dataset_name: str, max_records: int = 50) -> Optional[List[Dict[str, Any]]]:
+    """Fetches records from a dataset via API, limited after fetching."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/datasets/{dataset_name}/fetch")
+        response.raise_for_status()
+        data = response.json()
+        if data.get("success"):
+            all_records = data.get("data", [])
+            return all_records[:max_records] # Limit client-side for now
+        else:
+            st.error(f"API Error fetching '{dataset_name}': {data.get('message')}")
+            return None
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error fetching '{dataset_name}': {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error fetching '{dataset_name}': {e}")
+        logger.exception(f"Unexpected error in fetch_dataset_data for {dataset_name}")
+        return None
+
+def execute_nql_query(query: str) -> Optional[Dict[str, Any]]:
+    """Sends an NQL query to the API."""
+    try:
+        payload = {"query": query}
+        response = requests.post(f"{TENSORUS_API_URL}/query", json=payload)
+        # Handle specific NQL errors (400) vs other errors
+        if response.status_code == 400:
+             error_detail = response.json().get("detail", "Unknown NQL processing error")
+             return {"success": False, "message": error_detail, "results": None, "count": None}
+        response.raise_for_status() # Raise for 5xx etc.
+        return response.json() # Return the full NQLResponse structure
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error executing NQL query: {e}")
+        return {"success": False, "message": f"Connection Error: {e}", "results": None, "count": None}
+    except Exception as e:
+        st.error(f"Unexpected error executing NQL query: {e}")
+        logger.exception("Unexpected error in execute_nql_query")
+        return {"success": False, "message": f"Unexpected Error: {e}", "results": None, "count": None}
+
+# --- NEW/UPDATED Agent and Metrics Functions ---
+
+def list_all_agents() -> Optional[List[Dict[str, Any]]]:
+    """Fetches the list of all registered agents from the API."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/agents")
+        response.raise_for_status()
+        # The response is directly the list of AgentInfo objects
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error listing agents: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error listing agents: {e}")
+        logger.exception("Unexpected error in list_all_agents")
+        return None
+
+def get_agent_status(agent_id: str) -> Optional[Dict[str, Any]]:
+    """Fetches status for a specific agent from the API."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/agents/{agent_id}/status")
+        if response.status_code == 404:
+            st.error(f"Agent '{agent_id}' not found via API.")
+            return None
+        response.raise_for_status()
+        # Returns AgentStatus model dict
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error getting status for agent '{agent_id}': {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error getting status for agent '{agent_id}': {e}")
+        logger.exception(f"Unexpected error in get_agent_status for {agent_id}")
+        return None
+
+def get_agent_logs(agent_id: str, lines: int = 20) -> Optional[List[str]]:
+    """Fetches recent logs for a specific agent from the API."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/agents/{agent_id}/logs", params={"lines": lines})
+        if response.status_code == 404:
+            st.error(f"Agent '{agent_id}' not found via API for logs.")
+            return None
+        response.raise_for_status()
+        data = response.json()
+        # Returns AgentLogResponse model dict
+        return data.get("logs", [])
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error getting logs for agent '{agent_id}': {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error getting logs for agent '{agent_id}': {e}")
+        logger.exception(f"Unexpected error in get_agent_logs for {agent_id}")
+        return None
+
+def start_agent(agent_id: str) -> bool:
+    """Sends a start signal to an agent via the API."""
+    try:
+        response = requests.post(f"{TENSORUS_API_URL}/agents/{agent_id}/start")
+        if response.status_code == 404:
+            st.error(f"Agent '{agent_id}' not found via API.")
+            return False
+        # 202 Accepted is success, other 2xx might be okay too (e.g. already running if handled gracefully)
+        # 4xx errors indicate failure
+        if 200 <= response.status_code < 300:
+            api_response = response.json()
+            if api_response.get("success"):
+                 st.success(f"API: {api_response.get('message', 'Start signal sent.')}")
+                 return True
+            else:
+                 # API indicated logical failure (e.g., already running)
+                 st.warning(f"API: {api_response.get('message', 'Agent might already be running.')}")
+                 return False
+        else:
+             # Handle other potential errors reported by API
+             error_detail = "Unknown error"
+             try: error_detail = response.json().get("detail", error_detail)
+             except: pass
+             st.error(f"API Error starting agent '{agent_id}': {error_detail} (Status: {response.status_code})")
+             return False
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error starting agent '{agent_id}': {e}")
+        return False
+    except Exception as e:
+        st.error(f"Unexpected error starting agent '{agent_id}': {e}")
+        logger.exception(f"Unexpected error in start_agent for {agent_id}")
+        return False
+
+def stop_agent(agent_id: str) -> bool:
+    """Sends a stop signal to an agent via the API."""
+    try:
+        response = requests.post(f"{TENSORUS_API_URL}/agents/{agent_id}/stop")
+        if response.status_code == 404:
+            st.error(f"Agent '{agent_id}' not found via API.")
+            return False
+        if 200 <= response.status_code < 300:
+            api_response = response.json()
+            if api_response.get("success"):
+                 st.success(f"API: {api_response.get('message', 'Stop signal sent.')}")
+                 return True
+            else:
+                 st.warning(f"API: {api_response.get('message', 'Agent might already be stopped.')}")
+                 return False
+        else:
+             error_detail = "Unknown error"
+             try: error_detail = response.json().get("detail", error_detail)
+             except: pass
+             st.error(f"API Error stopping agent '{agent_id}': {error_detail} (Status: {response.status_code})")
+             return False
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error stopping agent '{agent_id}': {e}")
+        return False
+    except Exception as e:
+        st.error(f"Unexpected error stopping agent '{agent_id}': {e}")
+        logger.exception(f"Unexpected error in stop_agent for {agent_id}")
+        return False
+
+def get_dashboard_metrics() -> Optional[Dict[str, Any]]:
+    """Fetches dashboard metrics from the API."""
+    try:
+        response = requests.get(f"{TENSORUS_API_URL}/metrics/dashboard")
+        response.raise_for_status()
+        # Returns DashboardMetrics model dict
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"Connection Error fetching dashboard metrics: {e}")
+        return None
+    except Exception as e:
+        st.error(f"Unexpected error fetching dashboard metrics: {e}")
+        logger.exception("Unexpected error in get_dashboard_metrics")
+        return None