Update UI Frontend version 1.2.0 + Backend Integration

.streamlit/config.toml

@@ -0,0 +1,11 @@
+[theme]
+base="dark"
+textColor="#FFFFFF"
+font = "sans-serif"
+headingFont = "sans-serif"
+codeFont = "monospace"
+
+[theme.sidebar]
+font = "sans-serif"
+headingFont = "sans-serif"
+codeFont = "monospace"

app.py

@@ -0,0 +1,56 @@
+# Path: frontend/app.py
+# Main application entry point, setting up the app and routing.
+import sys
+import os
+from pathlib import Path
+
+project_root = Path(__file__).resolve().parent
+backend_dir = project_root / "backend"
+
+if str(backend_dir) not in sys.path:
+    sys.path.insert(0, str(backend_dir))
+
+# if str(current_dir) not in sys.path:
+#     sys.path.insert(0, str(current_dir))
+
+import streamlit as st
+from components.sidebar import render_sidebar
+from components.chat import render_chat_interface
+
+st.set_page_config(
+    page_icon=":material/sql:",
+    page_title="NL2SQL Assistant",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# def load_css():
+#     """Load custom CSS file"""
+#     css_path = os.path.join("assets", "styles.css")
+#     if os.path.exists(css_path):
+#         with open(css_path) as f:
+#             st.markdown(f"<style>{f.read()}</style>", unsafe_allow_html=True)
+
+def init_session_state():
+    """Initialize global variables and authentication states"""
+    if 'auth_stat' not in st.session_state:
+        st.session_state.auth_stat = "guest"
+
+    if 'username' not in st.session_state:
+        st.session_state.username = "guest"
+
+    if 'messages' not in st.session_state:
+        st.session_state.messages = []
+        
+    if 'current_model' not in st.session_state:
+        st.session_state.current_model = "default"
+
+def main():
+    # load_css()
+    init_session_state()
+
+    render_sidebar()
+    render_chat_interface()
+
+if __name__ == "__main__":
+    main()

backend/app/main.py

@@ -1,4 +1,4 @@
-# Path: app/main.py
+# Path: backend/app/main.py
 # Main entry point for the NL2SQL application
 import os
 from dotenv import load_dotenv

backend/server/api_server.py

@@ -0,0 +1,77 @@
+# Path: backend/server/api_server.py
+# FatAPI entry point
+import pandas as pd
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List, Dict, Any, Optional
+from src.database.db_manager import get_db_connection
+from src.nl2sql.hf_engine import get_models, DEFAULT_MODEL_ID
+from src.nl2sql.sql_agent import nl2sql_agent
+
+load_dotenv()
+app = FastAPI(title="NL2SQL Backend API")
+
+class chatRequest(BaseModel):
+    question: str
+    model_id: Optional[str] = DEFAULT_MODEL_ID
+
+class chatResponse(BaseModel):
+    status: str
+    sql: str
+    answer: str
+    data: List[Dict[str, Any]]
+    error: str
+
+@app.get("/models", response_model=List[str])
+def api_get_models():
+    """ Endpoint to fetch available models """
+    try:
+        models = get_models()
+        return models if models else [DEFAULT_MODEL_ID]
+    except Exception as e:
+        return [DEFAULT_MODEL_ID, "Qwen/Qwen2.5-Coder-7B-Instruct:featherless-ai"]
+
+@app.post("/chat", response_model=chatResponse)
+def api_process_chat(request: chatRequest):
+    """ Endpoint to process NL2SQL question and return data """
+    try:
+        resp = nl2sql_agent(user_question=request.question, model_id=request.model_id)
+
+        sql_query = resp.get('query', 'N/A')
+        nl_response = resp.get('nl_response', 'Could not synthesize text answer')
+        status = resp.get('status', 'error')
+        error_msg = resp.get('error', '')
+
+        results_list = []
+        execution_error = ""
+
+        if status != 'error' and sql_query != 'N/A':
+            conn = get_db_connection()
+            if conn:
+                try:
+                    df = pd.read_sql_query(sql_query, conn)
+                    results_list = df.to_dict(orient="records")
+                except Exception as e:
+                    execution_error = str(e)
+                    status = "error"
+                finally:
+                    conn.close()
+            else:
+                execution_error = ":material/warning: Failed to connect to the database."
+                status = "error"
+        return chatResponse(
+            status = status,
+            sql = sql_query,
+            answer = nl_response,
+            data = results_list,
+            error = execution_error if execution_error else error_msg
+        )
+    except Exception as e:
+        return chatResponse(
+            status = "error",
+            sql = "N/A",
+            answer = "An unexpected error occurred.",
+            data = [],
+            error = str(e)
+        )

backend/src/database/auth_db.json

@@ -0,0 +1,82 @@
+{
+    "admin": {
+        "password": "c1596a39b4dba28985cce3cb1bd83df3fb0730d09a4f28a830fda8764da71193",
+        "history": []
+    },
+    "dvwn": {
+        "password": "508f236e3d89d38a24689b345c0138f6667a6f18f305bd5f57255730c3869c0c",
+        "history": [],
+        "sessions": [
+            {
+                "title": "Which genres have more th",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "Which genres have more than 100 tracks? List the genre name and count."
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "Failed to compute response due to error: Execution failed on sql 'SELECT G.Name, COUNT(T.TrackId) AS TrackCount FROM Genre G JOIN Album A ON G.GenreId = A.GenreId JOIN Track T ON A.AlbumId = T.AlbumId GROUP BY G.Name HAVING COUNT(T.TrackId) > 100': no such column: A.GenreId"
+                    },
+                    {
+                        "role": "user",
+                        "content": "List the first and last names of all employees who are Sales Support Agents."
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "The Sales Support Agents are Jane Peacock, Margaret Park, and Steve Johnson.\n\n```sql\nSELECT FirstName, LastName FROM Employee WHERE Title = 'Sales Support Agent'\n```",
+                        "dataframe": [
+                            {
+                                "FirstName": "Jane",
+                                "LastName": "Peacock"
+                            },
+                            {
+                                "FirstName": "Margaret",
+                                "LastName": "Park"
+                            },
+                            {
+                                "FirstName": "Steve",
+                                "LastName": "Johnson"
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                "title": "Find the total number of ",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": "Find the total number of items sold for each media type."
+                    },
+                    {
+                        "role": "assistant",
+                        "content": "There was a total of 5 items sold across all media types.\n\n```sql\nSELECT mt.Name, COUNT(*) AS total_items_sold FROM MediaType mt JOIN (SELECT t.MediaTypeId, COUNT(*) AS items_sold FROM Track t JOIN Album a ON t.AlbumId = a.AlbumId GROUP BY t.MediaTypeId) AS m ON mt.MediaTypeId = m.MediaTypeId GROUP BY mt.Name;\n```",
+                        "dataframe": [
+                            {
+                                "Name": "AAC audio file",
+                                "total_items_sold": 1
+                            },
+                            {
+                                "Name": "MPEG audio file",
+                                "total_items_sold": 1
+                            },
+                            {
+                                "Name": "Protected AAC audio file",
+                                "total_items_sold": 1
+                            },
+                            {
+                                "Name": "Protected MPEG-4 video file",
+                                "total_items_sold": 1
+                            },
+                            {
+                                "Name": "Purchased AAC audio file",
+                                "total_items_sold": 1
+                            }
+                        ]
+                    }
+                ]
+            }
+        ]
+    }
+}

backend/src/nl2sql/hf_engine.py

@@ -15,7 +15,7 @@ MODEL_REGISTRY = {
     #"deepseek-ai/DeepSeek-R1-Distill-Qwen-32B:featherless-ai": "chat"
 }
 
-DEFAULT_MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct:featherless-ai"
+DEFAULT_MODEL_ID = "Qwen/Qwen2.5-Coder-7B-Instruct:featherless-ai"
 
 # Custom LangChain wrapper for HuggingFace Inference API
 class HFChatWrapper(LLM):

components/auth.py

@@ -0,0 +1,165 @@
+# Path: frontend/components/auth.py
+# Authentication component for handling user login and registration.
+import hashlib
+import json
+import os
+import streamlit as st
+import pandas as pd
+from typing import Tuple
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+AUTH_DB_PATH = Path("backend/src/database/auth_db.json")
+
+# Hashing password
+def hash_password(password):
+    """ Securely hashes a password """
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# Load user JSON-databases
+def load_userDB():
+    """ Load authenticated credentials from local JSON file """
+    if not AUTH_DB_PATH.exists():
+        AUTH_DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+        admin_user = os.getenv("DEFAULT_ADMIN_PASS")
+        if not admin_user:
+            raise ValueError("SECURITY HALT: DEFAULT_ADMIN_PASS environment is missing. Cannot initialize database securely.")
+        
+        default_db = {
+            "admin": {
+                "password": hash_password(admin_user),
+                "history": []
+            }
+        }
+
+        with open(AUTH_DB_PATH, "w") as f:
+            json.dump(default_db, f, indent=4)
+        return default_db
+    
+    with open(AUTH_DB_PATH, "r") as f:
+        return json.load(f)
+
+# Sace user data into the JSON-databases    
+def save_userDB(db_data: dict):
+    with open(AUTH_DB_PATH, "w") as f:
+        json.dump(db_data, f, indent=4)
+
+# User registration/create new account
+def register_user(username: str, password: str) -> Tuple[bool, str]:
+    """ Registers a new user record safely into the system """
+    if not username or not password:
+        return False, "Fields cannot be empty."
+    
+    db = load_userDB()
+    if username in db:
+        return False, "Username already exists. Please choose a different one."
+    
+    db[username] = {
+        "password": hash_password(password),
+        "history": []
+    }
+    save_userDB(db)
+    return True, "Account registered successfully!"
+
+# User login
+def verify_login(username: str, password: str) -> bool:
+    """ Verifies credentials against the authentication store """
+    db = load_userDB()
+    if username not in db:
+        return False
+    return db[username]["password"] == hash_password(password)
+
+# Save user's conversation
+def save_chat_history(username: str, session_messages: list):
+    """ Saves user's conversation logs to history """
+    if not username or username == "guest" or not session_messages:
+        return
+    
+    db = load_userDB()
+    if username in db:
+        if "sessions" not in db[username]:
+            db[username]["sessions"] = []
+
+        # Sanitize messages to make df JSON-serializable
+        sanitized_msg = []
+        for msg in session_messages:
+            clean_msg = {}
+            for key, value in msg.items():
+                if isinstance(value, pd.DataFrame):
+                    clean_msg[key] = value.to_dict(orient="records")
+                else:
+                    clean_msg[key] = value
+            sanitized_msg.append(clean_msg)
+
+        first_prompt = next((m["content"] for m in session_messages if m["role"] == "user"), "New Query")
+        truncated_title = first_prompt[:25]
+
+        # Check whether update an existing session / append new history
+        existing_sessions = db[username]["sessions"]
+        session_exists = False
+
+        for ses in existing_sessions:
+            if ses.get("title") == truncated_title:
+                ses["messages"] = sanitized_msg
+                session_exists = True
+                break
+        
+        if not session_exists:
+            existing_sessions.append({
+                "title": truncated_title,
+                "messages": sanitized_msg
+            })
+
+        db[username]["sessions"] = existing_sessions
+        save_userDB(db)
+        st.session_state.chat_sessions = existing_sessions
+
+# Retrieves user's history
+def get_history(username: str) -> list:
+    """ Retrieves saved conversation history for verified users """
+    db = load_userDB()
+    if username in db:
+        return db[username].get("sessions", [])
+    return []
+
+@st.dialog("Account Access Panel")
+def render_auth_dialog():
+    """
+    Streamlit UI native dialog: Handle custom login & signup cleanly without template injection
+    """
+    st.subheader("Sign In or Register")
+    tab1, tab2 = st.tabs([":material/lock: Login", ":material/new: Create Account"])
+
+    with tab1:
+        login_user = st.text_input("Username", key="login_user_input")
+        login_pass = st.text_input("Password", type="password", key="login_pass_input")
+        if st.button("Authenticate", type="primary", use_container_width=True):
+            if verify_login(login_user, login_pass):
+                st.session_state.auth_stat = "logged_in"
+                st.session_state.username = login_user
+                st.session_state.messages = get_history(login_user)
+                st.success(f"Welcome back, {login_user}!")
+                st.rerun()
+            else:
+                st.error("Invalid username or password credentials.")
+
+    with tab2:
+        reg_user = st.text_input("Username", key="reg_user_input")
+        reg_pass = st.text_input("Password", type="password", key="reg_user_pass")
+        reg_pass_confirm = st.text_input("Re-enter Password", type="password", key="reg_user_pass_confirm") 
+        if st.button("Sign Up Now", use_container_width=True):
+            if reg_pass != reg_pass_confirm:
+                st.error("Password does not match!")
+            else:
+                success, msg = register_user(reg_user, reg_pass)
+                if success:
+                    st.success(msg)
+                    # Login user automatically
+                    st.session_state.auth_stat = "logged_in"
+                    st.session_state.username = reg_user
+                    st.session_state.messages = []
+                    st.rerun()
+                else:
+                    st.error(msg)

components/chat.py

@@ -0,0 +1,84 @@
+# Path: frontend/components/chat.py
+# Chat component for handling user interactions and displaying chat history.
+import streamlit as st
+import pandas as pd
+from utils.api import process_userPrompt
+from components.auth import save_chat_history
+
+def render_chat_interface():
+    st.title(":material/sql: NL2SQL Assistant")
+    st.divider()
+
+    if not st.session_state.messages:
+        for _ in range(5):
+            st.write("")
+        _, center_col, _ = st.columns([1, 2, 1])
+        with center_col:
+            st.subheader(":material/calendar_view_month: Ask a question about your data (e.g., 'What is the top revenue in 2020')", anchor=False)
+
+    for idx, message in enumerate(st.session_state.messages):
+        role = message.get("role", "assistant")
+        content = message.get("content", "")
+
+        with st.chat_message(role):
+            st.markdown(content)
+
+            if message.get("dataframe") is not None:
+                raw_data = message["dataframe"]
+
+                if isinstance(raw_data, list):
+                    display_df = pd.DataFrame(raw_data)
+                else:
+                    display_df = raw_data
+                
+                st.dataframe(display_df, use_container_width=True)
+                # display_df = message["dataframe"]
+                # st.dataframe(message["dataframe"], use_container_width=True)
+
+                csv_data = display_df.to_csv().encode('utf-8')
+                if st.download_button(
+                    label=":material/download: Download CSV",
+                    data=csv_data,
+                    file_name=f'query_results_{idx}.csv',
+                    mime='text/csv',
+                    key=f"download_{idx}"
+                ):
+                    st.toast("The file has been downloaded!")
+    
+    if prompt := st.chat_input("Ask a question about yout data..."):
+        # Append user message
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        st.rerun()
+    
+    if st.session_state.messages and st.session_state.messages[-1]["role"] == "user":
+        with st.chat_message("assistant"):
+            with st.spinner("Analyzing schema metadata and generating execution context..."):
+                payload = process_userPrompt(
+                    question=st.session_state.messages[-1]["content"],
+                    model_id=st.session_state.current_model
+                )
+
+            if payload["status"] == "error":
+                st.error(f"Interrupted:\n{payload['error']}")
+                response_text = f"Failed to compute response due to error: {payload['error']}"
+                st.session_state.messages.append({"role": "assistant", "content": response_text})
+            else:
+                st.markdown(payload["answer"])
+                st.code(payload["sql"], language="sql")
+                
+                display_df = payload["data"]
+                if not display_df.empty:
+                    display_df = display_df.copy()
+                    display_df.index = range(1, len(display_df) + 1)
+                    display_df.index.name = "No."
+                
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": f"{payload['answer']}\n\n```sql\n{payload['sql']}\n```",
+                    "dataframe": display_df if not display_df.empty else None
+                })
+
+                if st.session_state.auth_stat != 'guest':
+                    save_chat_history(st.session_state.username, st.session_state.messages)
+
+                st.rerun()

components/sidebar.py

@@ -0,0 +1,95 @@
+# Path: frontend/components/sidebar.py
+# Sidebar component for navigation and additional options.
+import streamlit as st
+from utils.api import get_available_models
+from components.auth import render_auth_dialog, save_chat_history, save_userDB, load_userDB
+
+@st.dialog("Delete Confirmation")
+def confirm_delete(idx, session_title):
+    st.warning(f"Are you sure you want to delete '{session_title}'?")
+    st.write(":material/warning: This action cannot be undone!")
+
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("Cancel", use_container_width=True):
+            st.rerun()
+    
+    with col2:
+        if st.button("Delete", type="primary", use_container_width=True):
+            deleted_session = st.session_state.chat_sessions.pop(idx)
+            st.toast("Item permanently deleted!", icon=":material/delete:")
+
+            if st.session_state.messages == deleted_session.get("messages", []):
+                st.session_state.messages = []
+
+            db = load_userDB()
+            if st.session_state.username in db:
+                db[st.session_state.username]["sessions"] = st.session_state.chat_sessions
+                save_userDB(db)
+            st.rerun()
+
+def render_sidebar():
+    with st.sidebar:
+        #st.subheader(":material/sql:", anchor=False)
+        if st.session_state.auth_stat == 'guest':
+            if st.button(":material/login: Login / Sign Up", type="secondary", use_container_width=True):
+                render_auth_dialog()
+        else:
+            if st.button(":material/logout: Logout", use_container_width=True):
+                st.session_state.auth_stat = 'guest'
+                st.session_state.username = 'guest'
+                st.session_state.messages = []
+                if "chat_sessions" in st.session_state:
+                    del st.session_state.chat_sessions
+                st.rerun()
+
+        if st.button(":material/add: New Chat", use_container_width=True):
+            if st.session_state.auth_stat != 'guest':
+                save_chat_history(st.session_state.username, st.session_state.messages)
+            st.session_state.messages = []
+            st.rerun()
+        st.divider()
+
+        st.caption("Database Connection")
+        st.success(icon=":material/circle:", body="Connected")
+
+        st.caption("Model Selector")
+        available_models = get_available_models()
+        st.session_state.current_model = st.selectbox(
+            "Select model:",
+            available_models,
+            label_visibility="collapsed"
+        )
+        st.divider()
+
+        st.caption("History")
+        if st.session_state.auth_stat == 'guest':
+            st.info("You are in Guest Mode. Your conversation history will not be saved.")
+        else:
+            st.caption(f"Authenticated as: {st.session_state.username}")
+            if "chat_sessions" not in st.session_state:
+                db = load_userDB()
+                st.session_state.chat_sessions = db.get(st.session_state.username, {}).get("sessions", [])
+ 
+            if st.session_state.messages:
+                st.button(f":material/chat_bubble: Active Session Logs", disabled=True, use_container_width=True)
+
+            if not st.session_state.chat_sessions:
+                st.caption('Query your database now')
+            else:
+                for idx, session in enumerate(st.session_state.chat_sessions):
+                    col1, col2 = st.columns([0.80, 0.20])
+
+                    with col1:
+                        session_title = session.get("title", f"Chat {idx + 1}")
+                        if st.button(
+                            f":material/history: {session_title[:15]}...",
+                            key=f"load_session_{idx}",
+                            use_container_width=True
+                        ):
+                            st.session_state.messages = session.get("messages", [])
+                            st.rerun()
+
+                    with col2:
+                        if st.button(":material/delete:", key=f"delete_session_{idx}"):
+                            confirm_delete(idx, session_title)

frontend/app.py

@@ -1,27 +0,0 @@
-# Path: frontend/app.py
-# Main application entry point, setting up the app and routing.
-import streamlit as st
-from components import auth, sidebar, chat
-
-st.set_page_config(page_icon=":material/sql:", page_title="NL2SQL Assistant", layout="wide")
-
-# Initialize global session state variables
-if 'user_id' not in st.session_state:
-    st.session_state['user_id'] = None
-if 'guest_mode' not in st.session_state:
-    st.session_state['guest_mode'] = False
-if 'current_session_id' not in st.session_state:
-    st.session_state['current_session_id'] = None
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
-
-def main():
-    if st.session_state['user_id'] is None and not st.session_state['guest_mode']:
-        # User not logged in, show authentication page
-        auth.render_auth()
-    else:
-        sidebar.render_sidebar()
-        chat.render_chat_interface()
-
-if __name__ == "__main__":
-    main()

frontend/components/auth.py

@@ -1,33 +0,0 @@
-# Path: frontend/components/auth.py
-# Authentication component for handling user login and registration.
-import streamlit as st
-from utils import api
-
-def render_auth():
-    st.title("Welcome to NL2SQL Assistant Demo")
-    tab_login, tab_signup = st.tabs(["Login", "Sign Up"])
-
-    with tab_login:
-        with st.form("login_form"):
-            email = st.text_input("Email")
-            password = st.text_input("Password", type="password")
-            if st.form_submit_button("Login"):
-                response = api.user_login(email, password)
-                if response.get("success"):
-                    st.session_state['user_id'] = response.get("user_id")
-                    st.rerun()
-                else:
-                    st.error("Invalid email or password. Please try again.")
-    
-    with tab_signup:
-        with st.form("signup_form"):
-            email = st.text_input("Email")
-            new_password = st.text_input("Password", type="password")
-            if st.form_submit_button("Sign Up"):
-                st.success("Account created successfully! Plase login to continue.")
-    
-    st.divider()
-    st.markdown("Or continue as a guest:")
-    if st.button("Continue as Guest", use_container_width=True):
-        st.session_state['guest_mode'] = True
-        st.rerun()

frontend/components/chat.py

@@ -1,52 +0,0 @@
-# Path: frontend/components/chat.py
-# Chat component for handling user interactions and displaying chat history.
-import streamlit as st
-import pandas as pd
-from utils import api
-
-def render_chat_interface():
-    st.title(":material/sql: NL2SQL Assistant")
-    st.divider()
-    
-    # Render existing messages
-    for msg in st.session_state['messages']:
-        with st.chat_message(msg["role"]):
-            st.markdown(msg["content"])
-            if "sql" in msg and msg["sql"]:
-                st.code(msg["sql"], language="sql")
-            if "data" in msg and msg["data"]:
-                st.dataframe(pd.DataFrame(msg["data"]))
-    
-    # Input area for new messages
-    if prompt := st.chat_input("Ask a question about your database (e.g., 'Show me top revenue in 2020')"):
-        # Display user prompt
-        st.session_state['messages'].append({"role": "user", "content": prompt})
-        with st.chat_message("user"):
-            st.markdown(prompt)
-
-        # Process and get assistant response
-        with st.chat_message("assistant"):
-            with st.spinner("Executing LangChain pipeline for RAG-based schema retrieval..."):
-                response = api.send_chat_message(
-                    user_id = st.session_state['user_id'],
-                    session_id = st.session_state.get('current_session_id'),
-                    message = prompt
-                )
-
-                # Render results
-                st.markdown(response.get("answer", "Generated SQL based on the query:"))
-                st.code(response["sql"], language="sql")
-                if response.get("data"):
-                    st.dataframe(pd.DataFrame(response["data"]))
-
-                # Save conversations to session state
-                st.session_state['messages'].append({
-                    "role": "assistant",
-                    "content": response.get("answer", ""),
-                    "sql": response["sql"],
-                    "data": response.get("data")
-                })
-
-                # Save session ID automatically if user is authenticated and it's a new session
-                if not st.session_state['guest_mode'] and st.session_state['current_session_id'] is None:
-                    st.session_state['current_session_id'] = response.get("session_id")

frontend/components/sidebar.py

@@ -1,58 +0,0 @@
-# Path: frontend/components/sidebar.py
-# Sidebar component for navigation and additional options.
-import streamlit as st
-from utils import api
-
-def render_sidebar():
-    with st.sidebar:
-        st.header(":material/sql:")
-
-        if st.button(":material/add: New Chat", use_container_width=True):
-            st.session_state['current_session_id'] = None
-            st.session_state['messages'] = []
-            st.rerun()
-        st.divider()
-
-        st.subheader("Model Selection")
-        model_options = st.selectbox(
-            "Choose a model:",
-            ["Model A", "Model B"],
-            label_visibility="collapsed"
-        )
-
-        # Guest View
-        if st.session_state['guest_mode']:
-            st.info("You are in Guest Mode. Your conversation history will not be saved.")
-            st.write("Create an account to save your queries.")
-            if st.button("Log In / Sign Up", use_container_width=True):
-                st.session_state['guest_mode'] = False
-                st.rerun()
-        # Authenticated User View
-        else:
-            st.header(":material/history: History")
-            # Fetch history
-            history = api.get_user_history(st.session_state['user_id'])
-
-            for time_label, sessions in history.items():
-                if sessions:
-                    st.caption(time_label)
-                    for session in sessions:
-                        col1, col2 = st.columns([5, 1])
-
-                        with col1:
-                            if st.button(f":material/chat_bubble: {session['title'][:20]}", key=f"sel_{session['id']}", use_container_width=True):
-                                st.session_state['current_session_id'] = session['id']
-                                st.session_state['messages'] = api.get_session_messages(session['id'])
-                                st.rerun()
-                        with col2:
-                            if st.button(":material/delete:", key=f"del_{session['id']}", help="Delete Chat History"):
-                                if api.del_conversation(session['id']):
-                                    if st.session_state['current_session_id'] == session['id']:
-                                        st.session_state['current_session_id'] = None
-                                        st.session_state['messages'] = []
-                                    st.rerun()
-            st.divider()
-            if st.button(":material/logout: Logout", use_container_width=True):
-                st.session_state['user_id'] = None
-                st.session_state['messages'] = []
-                st.rerun()

frontend/utils/api.py

@@ -1,2 +0,0 @@
-# Path: frontend/utils/api.py
-# API utility functions for making requests to the backend server.

utils/api.py

@@ -0,0 +1,49 @@
+# Path: frontend/utils/api.py
+# API utility functions for making requests to the backend server.
+import pandas as pd
+import streamlit as st
+import requests
+from typing import List, Dict, Any, Tuple
+
+FASTAPI_BASE_URL = "http://localhost:8000"
+
+@st.cache_data(ttl=600)
+def get_available_models() -> List[str]:
+    """ Fetches available models via FastAPI """
+    try:
+       resp = requests.get(f"{FASTAPI_BASE_URL}/models", timeout=10)
+       resp.raise_for_status()
+       return resp.json()
+    except Exception as e:
+        st.warning(f"Backend unreachable. Using fallback models. Error: {e}")
+        return ["Qwen/Qwen2.5-Coder-7B-Instruct:featherless-ai"]
+
+def process_userPrompt(question: str, model_id: str) -> Dict[str, Any]:
+    """ Send user's question to FastAPI and parses the response """
+    try:
+        payload = {
+            "question": question,
+            "model_id": model_id
+        }
+
+        resp = requests.post(f"{FASTAPI_BASE_URL}/chat", json=payload, timeout=60)
+        resp.raise_for_status()
+        data = resp.json()
+
+        df_results = pd.DataFrame(data["data"]) if data.get("data") else pd.DataFrame()
+
+        return {
+            "status": data["status"],
+            "sql": data["sql"],
+            "answer": data["answer"],
+            "data": df_results,
+            "error":  data["error"]
+        }
+    except requests.exceptions.RequestException as e:
+        return {
+            "status": "error",
+            "sql": "N/A",
+            "answer": "Failed to connect to the backend server.",
+            "data": pd.DataFrame(),
+            "error": str(e)
+        }