Update app.py

app.py

@@ -1,299 +1,538 @@
+# app.py
 import streamlit as st
 import os
-import glob
-from dotenv import load_dotenv
 import time
-
-from langchain_community.document_loaders import (
-    PyPDFLoader,
-    Docx2txtLoader,
-    UnstructuredExcelLoader,
-    JSONLoader,
-    UnstructuredFileLoader # Generic loader, good for tables
-)
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain.embeddings import HuggingFaceEmbeddings
-from langchain_community.vectorstores import FAISS
-from langchain_groq import ChatGroq
-from langchain.chains import RetrievalQA
-from langchain.prompts import PromptTemplate
-from langchain.schema.runnable import RunnablePassthrough
-from langchain.schema.output_parser import StrOutputParser
-
-# --- Configuration ---
-DOCS_DIR = "docs"
-# Using a local sentence transformer model for embeddings
-EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
-CACHE_DIR = ".streamlit_cache" # For potential disk-based caching if needed beyond Streamlit's default
-
-# Create docs and cache directory if they don't exist
-if not os.path.exists(DOCS_DIR):
-    os.makedirs(DOCS_DIR)
-if not os.path.exists(CACHE_DIR):
-    os.makedirs(CACHE_DIR)
-
-# --- Helper Function for Document Loading ---
-def get_loader(file_path):
-    """Detects file type and returns appropriate Langchain loader."""
-    _, ext = os.path.splitext(file_path)
-    ext = ext.lower()
-    # Prioritize UnstructuredFileLoader for robust table and content extraction
-    # UnstructuredFileLoader can handle many types, but we can specify if needed
-    if ext in ['.pdf', '.docx', '.doc', '.xlsx', '.xls', '.json', '.txt', '.md', '.html', '.xml', '.eml', '.msg']:
-        return UnstructuredFileLoader(file_path, mode="elements", strategy="fast") # "elements" is good for tables
-    # Fallback or specific loaders if UnstructuredFileLoader has issues with a particular file
-    # elif ext == ".pdf":
-    #    return PyPDFLoader(file_path) # Basic PDF loader
-    # elif ext in [".docx", ".doc"]:
-    #    return Docx2txtLoader(file_path) # Basic DOCX loader
-    # elif ext in [".xlsx", ".xls"]:
-    #    return UnstructuredExcelLoader(file_path, mode="elements") # Unstructured for Excel
-    # elif ext == ".json":
-    #    return JSONLoader(file_path, jq_schema='.[]', text_content=False) # Adjust jq_schema as needed
-    else:
-        st.warning(f"Unsupported file type: {ext}. Skipping {os.path.basename(file_path)}")
+from datetime import datetime, timezone
+import json
+import PyPDF2
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
+from twilio.rest import Client
+from groq import Groq
+
+# --- Page Configuration ---
+st.set_page_config(page_title="RAG Customer Support Chatbot", layout="wide")
+
+# --- Default Configurations & File Paths ---
+DEFAULT_TWILIO_ACCOUNT_SID_FALLBACK = "" # Fallback if secret "TWILIO_SID" is not found
+DEFAULT_TWILIO_AUTH_TOKEN_FALLBACK = ""  # Fallback if secret "TWILIO_TOKEN" is not found
+DEFAULT_GROQ_API_KEY_FALLBACK = ""       # Fallback if secret "GROQ_API_KEY" is not found
+
+DEFAULT_TWILIO_CONVERSATION_SERVICE_SID = "" 
+DEFAULT_TWILIO_BOT_WHATSAPP_IDENTITY = "whatsapp:+14155238886" # Twilio Sandbox default
+DEFAULT_EMBEDDING_MODEL_NAME = "sentence-transformers/all-MiniLM-L6-v2"
+DEFAULT_POLLING_INTERVAL_S = 30
+DOCS_FOLDER = "docs/"
+CUSTOMER_ORDERS_FILE = os.path.join(DOCS_FOLDER, "CustomersOrder.json")
+PRODUCTS_FILE = os.path.join(DOCS_FOLDER, "products.json")
+POLICY_PDF_FILE = os.path.join(DOCS_FOLDER, "ProductReturnPolicy.pdf")
+FAQ_PDF_FILE = os.path.join(DOCS_FOLDER, "FAQ.pdf")
+
+# --- Application Secrets Configuration ---
+# These are the primary keys fetched from st.secrets as per user request
+APP_TWILIO_ACCOUNT_SID = st.secrets.get("TWILIO_SID")
+APP_TWILIO_AUTH_TOKEN = st.secrets.get("TWILIO_TOKEN")
+APP_GROQ_API_KEY = st.secrets.get("GROQ_API_KEY")
+
+# Other secrets with fallback to defaults/sidebar input (if secrets not found)
+APP_TWILIO_CONVERSATION_SERVICE_SID_SECRET = st.secrets.get("TWILIO_CONVERSATION_SERVICE_SID")
+APP_TWILIO_BOT_WHATSAPP_IDENTITY_SECRET = st.secrets.get("TWILIO_BOT_WHATSAPP_IDENTITY")
+
+
+# --- RAG Processing Utilities ---
+def load_json_data(file_path):
+    """Loads data from a JSON file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return data
+    except FileNotFoundError:
+        st.error(f"Error: JSON file not found at {file_path}")
+        return None
+    except json.JSONDecodeError:
+        st.error(f"Error: Could not decode JSON from {file_path}")
+        return None
+    except Exception as e:
+        st.error(f"An unexpected error occurred while loading {file_path}: {e}")
         return None
 
-# --- Caching Functions ---
-
-@st.cache_resource(show_spinner="Loading and Processing Documents...")
-def load_and_process_documents(docs_path: str):
-    """
-    Loads documents from the specified path, processes them, and splits into chunks.
-    Uses UnstructuredFileLoader for potentially better table extraction.
-    """
-    documents = []
-    doc_files = []
-    for ext in ["*.pdf", "*.docx", "*.xlsx", "*.json", "*.txt", "*.md"]:
-        doc_files.extend(glob.glob(os.path.join(docs_path, ext)))
-
-    if not doc_files:
-        st.error(f"No documents found in the '{docs_path}' directory. Please add some documents.")
-        st.info("Supported formats: .pdf, .docx, .xlsx, .json, .txt, .md")
+def load_pdf_data(file_path):
+    """Extracts text from a PDF file, page by page."""
+    try:
+        with open(file_path, 'rb') as f:
+            reader = PyPDF2.PdfReader(f)
+            text_pages = []
+            for page_num in range(len(reader.pages)):
+                page = reader.pages[page_num]
+                text_pages.append(page.extract_text() or "")
+        return text_pages
+    except FileNotFoundError:
+        st.error(f"Error: PDF file not found at {file_path}")
+        return []
+    except Exception as e:
+        st.error(f"An error occurred while processing PDF {file_path}: {e}")
         return []
 
-    for file_path in doc_files:
-        try:
-            st.write(f"Processing: {os.path.basename(file_path)}...") # Show progress
-            loader = get_loader(file_path)
-            if loader:
-                loaded_docs = loader.load()
-                # Add source metadata to each document for better traceability
-                for doc in loaded_docs:
-                    doc.metadata["source"] = os.path.basename(file_path)
-                documents.extend(loaded_docs)
-        except Exception as e:
-            st.error(f"Error loading {os.path.basename(file_path)}: {e}")
-            st.warning(f"Skipping file {os.path.basename(file_path)} due to error.")
-
-    if not documents:
-        st.error("No documents were successfully loaded or processed.")
+def chunk_text(text_pages, chunk_size=1000, chunk_overlap=200):
+    """Chunks text from PDF pages into smaller, overlapping pieces."""
+    full_text = "\n".join(text_pages)
+    if not full_text.strip():
         return []
+    chunks = []
+    start = 0
+    while start < len(full_text):
+        end = start + chunk_size
+        chunks.append(full_text[start:end])
+        if end >= len(full_text):
+            break
+        start += (chunk_size - chunk_overlap)
+        if start >= len(full_text):
+            break
+    return [chunk for chunk in chunks if chunk.strip()]
+
+@st.cache_resource(show_spinner="Initializing embedding model...")
+def initialize_embedding_model(model_name=DEFAULT_EMBEDDING_MODEL_NAME):
+    """Initializes and returns a SentenceTransformer model."""
+    try:
+        model = SentenceTransformer(model_name)
+        return model
+    except Exception as e:
+        st.error(f"Error initializing embedding model '{model_name}': {e}")
+        return None
 
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-    chunked_documents = text_splitter.split_documents(documents)
+@st.cache_resource(show_spinner="Building FAISS index for PDF documents...")
+def create_faiss_index(_text_chunks, _embedding_model):
+    """Creates a FAISS index from text chunks and an embedding model."""
+    if not _text_chunks or _embedding_model is None:
+        st.warning("Cannot create FAISS index: No text chunks or embedding model available.")
+        return None, []
+    try:
+        valid_chunks = [str(chunk) for chunk in _text_chunks if chunk and isinstance(chunk, str) and chunk.strip()]
+        if not valid_chunks:
+            st.warning("No valid text chunks to embed for FAISS index.")
+            return None, []
+        embeddings = _embedding_model.encode(valid_chunks, convert_to_tensor=False)
+        if embeddings.ndim == 1:
+            embeddings = embeddings.reshape(1, -1)
+        if embeddings.shape[0] == 0:
+             st.warning("No embeddings were generated for FAISS index.")
+             return None, []
+        dimension = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dimension)
+        index.add(np.array(embeddings, dtype=np.float32))
+        return index, valid_chunks
+    except Exception as e:
+        st.error(f"Error creating FAISS index: {e}")
+        return None, []
 
-    if not chunked_documents:
-        st.error("Document processing resulted in no text chunks. Check document content and parsing.")
+def search_faiss_index(index, query_text, embedding_model, indexed_chunks, k=3):
+    """Searches the FAISS index and returns top_k relevant chunk texts."""
+    if index is None or embedding_model is None or not query_text:
+        return []
+    try:
+        query_embedding = embedding_model.encode([query_text], convert_to_tensor=False)
+        if query_embedding.ndim == 1:
+            query_embedding = query_embedding.reshape(1, -1)
+        distances, indices = index.search(np.array(query_embedding, dtype=np.float32), k)
+        results = []
+        for i in range(len(indices[0])):
+            idx = indices[0][i]
+            if 0 <= idx < len(indexed_chunks):
+                results.append(indexed_chunks[idx])
+        return results
+    except Exception as e:
+        st.error(f"Error searching FAISS index: {e}")
         return []
 
-    st.success(f"Successfully loaded and processed {len(doc_files)} documents into {len(chunked_documents)} chunks.")
-    return chunked_documents
+def get_order_details(order_id, customer_orders_data):
+    """Retrieves order details for a given order_id."""
+    if not customer_orders_data:
+        return "Customer order data is not loaded."
+    for order in customer_orders_data:
+        if order.get("order_id") == order_id:
+            return json.dumps(order, indent=2)
+    return f"No order found with ID: {order_id}."
+
+def get_product_info(query, products_data):
+    """Retrieves product information based on a query."""
+    if not products_data:
+        return "Product data is not loaded."
+    query_lower = query.lower()
+    found_products = []
+    for product in products_data:
+        if query_lower in (product.get("name", "").lower()) or \
+           query_lower in (product.get("description", "").lower()) or \
+           query_lower == (product.get("product_id", "").lower()):
+            found_products.append(product)
+    if found_products:
+        return json.dumps(found_products, indent=2)
+    return f"No product information found matching your query: '{query}'."
+
+# --- LLM Operations ---
+@st.cache_data(show_spinner="Generating response with LLaMA3...")
+def generate_response_groq(_groq_client, query, context, model="llama3-8b-8192"):
+    """Generates a response using GROQ LLaMA3 API."""
+    if not _groq_client:
+        return "GROQ client not initialized. Please check API key."
+    if not query:
+        return "Query is empty."
+    prompt = f"""You are a helpful customer support assistant.
+Use the following context to answer the user's question.
+If the context doesn't contain the answer, state that you don't have enough information.
+Do not make up information. Be concise and polite.
+
+Context:
+{context}
+
+User Question: {query}
+
+Assistant Answer:
+"""
+    try:
+        chat_completion = _groq_client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": "You are a helpful customer support assistant."},
+                {"role": "user", "content": prompt}
+            ],
+            model=model, temperature=0.7, max_tokens=1024, top_p=1
+        )
+        response = chat_completion.choices[0].message.content
+        return response
+    except Exception as e:
+        st.error(f"Error calling GROQ API: {e}")
+        return "Sorry, I encountered an error while trying to generate a response."
 
-@st.cache_resource(show_spinner="Creating Vector Store (Embeddings)...")
-def create_vector_store(_documents, _embedding_model_name: str):
-    """Creates a FAISS vector store from the given documents and embedding model."""
-    if not _documents:
-        st.warning("Cannot create vector store: No documents processed.")
+def initialize_groq_client(api_key_val):
+    """Initializes the GROQ client."""
+    if not api_key_val: # Changed parameter name to avoid conflict
+        st.warning("GROQ API Key is missing.")
         return None
     try:
-        embeddings = HuggingFaceEmbeddings(model_name=_embedding_model_name)
-        vector_store = FAISS.from_documents(_documents, embedding=embeddings)
-        st.success("Vector Store created successfully!")
-        return vector_store
+        client = Groq(api_key=api_key_val)
+        return client
     except Exception as e:
-        st.error(f"Error creating vector store: {e}")
+        st.error(f"Failed to initialize GROQ client: {e}")
         return None
 
-@st.cache_resource(show_spinner="Initializing LLM...")
-def get_llm(api_key: str, model_name: str = "llama3-8b-8192"): # UPDATED MODEL
-    """Initializes the Groq LLM."""
-    if not api_key:
-        st.error("GROQ_API_KEY not found! Please set it in your environment variables or a .env file.")
+# --- Twilio Operations ---
+def initialize_twilio_client(acc_sid, auth_tkn): # Changed parameter names
+    """Initializes the Twilio client."""
+    if not acc_sid or not auth_tkn:
+        st.warning("Twilio Account SID or Auth Token is missing.")
         return None
     try:
-        # Available models (check Groq documentation for the latest):
-        # "llama3-8b-8192" (good balance of speed and capability)
-        # "llama3-70b-8192" (more powerful, potentially slower)
-        # "gemma-7b-it"
-        llm = ChatGroq(temperature=0, groq_api_key=api_key, model_name=model_name)
-        st.sidebar.info(f"LLM Initialized: {model_name}") # Add info about which model is used
-        return llm
+        client = Client(acc_sid, auth_tkn)
+        return client
     except Exception as e:
-        st.error(f"Error initializing Groq LLM: {e}")
+        st.error(f"Failed to initialize Twilio client: {e}")
         return None
 
-# --- RAG Chain Setup ---
-def get_rag_chain(llm, retriever, prompt_template):
-    """Creates the Retrieval QA chain."""
-    prompt = PromptTemplate.from_template(prompt_template)
-    rag_chain = (
-        {"context": retriever, "question": RunnablePassthrough()}
-        | prompt
-        | llm
-        | StrOutputParser()
-    )
-    return rag_chain
-
-# --- Main Application Logic ---
-def main():
-    load_dotenv()
-    groq_api_key = os.getenv("GROQ_API_KEY")
-
-    # --- UI Setup ---
-    st.set_page_config(page_title="Internal Knowledge Base AI", layout="wide", initial_sidebar_state="expanded")
-
-    # Custom CSS (remains the same)
-    st.markdown("""
-    <style>
-        .reportview-container .main .block-container{
-            padding-top: 2rem;
-            padding-bottom: 2rem;
-        }
-        .st-emotion-cache-z5fcl4 {
-            padding-top: 1rem;
-        }
-        .response-area {
-            background-color: #f0f2f6;
-            padding: 15px;
-            border-radius: 5px;
-            margin-top: 10px;
-        }
-    </style>
-    """, unsafe_allow_html=True)
-
-    st.title("📚 Internal Knowledge Base AI �")
-
-    st.sidebar.header("System Status")
-    status_placeholder = st.sidebar.empty()
-    status_placeholder.info("Initializing...")
-
-
-    if not groq_api_key:
-        status_placeholder.error("GROQ API Key not configured. Application cannot start.")
-        st.stop()
-
-    # --- Knowledge Base Loading ---
-    with st.spinner("Knowledge Base is loading... Please wait."):
-        start_time = time.time()
-        processed_documents = load_and_process_documents(DOCS_DIR)
-        if not processed_documents:
-            status_placeholder.error("Failed to load or process documents. Check logs and `docs` folder.")
-            st.stop()
-
-        vector_store = create_vector_store(processed_documents, EMBEDDING_MODEL_NAME)
-        if not vector_store:
-            status_placeholder.error("Failed to create vector store. Application cannot proceed.")
-            st.stop()
-
-        # Pass the selected model to get_llm
-        llm = get_llm(groq_api_key, model_name="llama3-8b-8192") # Hardcoded to use llama3-8b-8192
-        if not llm:
-            # Error is already shown by get_llm, but update status_placeholder too
-            status_placeholder.error("Failed to initialize LLM. Application cannot proceed.")
-            st.stop()
-
-        end_time = time.time()
-        # status_placeholder is updated by get_llm or on success below
-        status_placeholder.success(f"Application Ready! (Loaded in {end_time - start_time:.2f}s)")
-
-    retriever = vector_store.as_retriever(search_kwargs={"k": 5})
-
-    # --- Query Input and Response ---
-
-    st.markdown("---")
-    st.subheader("Ask a question about our documents:")
-
-    # Prompt templates
-    GENERAL_QA_PROMPT = """
-    You are an AI assistant for our internal knowledge base.
-    Your goal is to provide accurate and concise answers based ONLY on the provided context.
-    Do not make up information. If the answer is not found in the context, state that clearly.
-    Ensure your answers are directly supported by the text.
-    Accuracy is paramount.
-
-    Context:
-    {context}
-
-    Question: {question}
-
-    Answer:
-    """
-
-    ORDER_STATUS_PROMPT = """
-    You are an AI assistant helping with customer order inquiries.
-    Based ONLY on the following retrieved information from our order system and policies:
-    {context}
-
-    The customer's query is: {question}
-
-    Please perform the following steps:
-    1. Carefully analyze the context for any order details (Order ID, Customer Name, Status, Items, Dates, etc.).
-    2. If an order matching the query (or related to a name in the query) is found in the context:
-        - Address the customer by their name if available in the order details (e.g., "Hello [Customer Name],").
-        - Provide ALL available information about their order, including Order ID, status, items, dates, and any other relevant details found in the context.
-        - Be comprehensive and clear.
-    3. If no specific order details are found in the context that match the query, or if the context is insufficient, politely state that you couldn't find the specific order information in the provided documents and suggest they contact support for further assistance.
-    4. Do NOT invent or infer any information not explicitly present in the context.
-
-    Answer:
-    """
-
-    if "messages" not in st.session_state:
-        st.session_state.messages = []
-
-    query = st.text_input("Enter your question:", key="query_input", placeholder="e.g., 'What is the return policy?' or 'Status of order for John Doe?'")
-
-    if st.button("Submit", key="submit_button"):
-        if query:
-            st.session_state.messages.append({"role": "user", "content": query})
-
-            current_model_info = st.sidebar.empty() # Placeholder for current mode info
-
-            if "order" in query.lower() and ("status" in query.lower() or "track" in query.lower() or "update" in query.lower() or any(name_part.lower() in query.lower() for name_part in ["customer", "client", "name"])):
-                active_prompt_template = ORDER_STATUS_PROMPT
-                current_model_info.info("Mode: Order Status Query")
-            else:
-                active_prompt_template = GENERAL_QA_PROMPT
-                current_model_info.info("Mode: General Query")
-
-            rag_chain = get_rag_chain(llm, retriever, active_prompt_template)
-
-            with st.spinner("Thinking..."):
-                try:
-                    response = rag_chain.invoke(query)
-                    st.session_state.messages.append({"role": "assistant", "content": response})
-                except Exception as e:
-                    st.error(f"Error during RAG chain invocation: {e}")
-                    response = "Sorry, I encountered an error while processing your request."
-                    st.session_state.messages.append({"role": "assistant", "content": response})
-        else:
-            st.warning("Please enter a question.")
-
-    st.markdown("---")
-    st.subheader("Response:")
-    response_area = st.container()
-    # Ensure response_area is robust against empty messages or incorrect last role
-    last_assistant_message = "Ask a question to see the answer here."
-    if st.session_state.messages and st.session_state.messages[-1]['role'] == 'assistant':
-        last_assistant_message = st.session_state.messages[-1]['content']
-
-    response_area.markdown(f"<div class='response-area'>{last_assistant_message}</div>", unsafe_allow_html=True)
-
+def get_new_whatsapp_messages(twilio_client, conversation_service_sid_val, bot_start_time_utc, # Renamed
+                              processed_message_sids, bot_whatsapp_identity_val): # Renamed
+    """Fetches new, unanswered WhatsApp messages from Twilio Conversations."""
+    if not twilio_client:
+        st.warning("Twilio client not initialized.")
+        return []
+    if not conversation_service_sid_val:
+        st.warning("Twilio Conversation Service SID not provided.")
+        return []
 
-    st.sidebar.markdown("---")
-    st.sidebar.markdown("Built with ❤️ using Streamlit & Langchain & Groq")
+    new_messages_to_process = []
+    try:
+        conversations = twilio_client.conversations.v1 \
+            .services(conversation_service_sid_val) \
+            .conversations \
+            .list(limit=50)
+
+        for conv in conversations:
+            if conv.date_updated and conv.date_updated > bot_start_time_utc:
+                messages = twilio_client.conversations.v1 \
+                    .services(conversation_service_sid_val) \
+                    .conversations(conv.sid) \
+                    .messages \
+                    .list(order='desc', limit=10)
+
+                for msg in messages:
+                    if msg.sid in processed_message_sids:
+                        continue
+                    if msg.author and msg.author.lower() != bot_whatsapp_identity_val.lower() and \
+                       msg.date_created and msg.date_created > bot_start_time_utc:
+                        new_messages_to_process.append({
+                            "conversation_sid": conv.sid, "message_sid": msg.sid,
+                            "author_identity": msg.author, "message_body": msg.body,
+                            "timestamp_utc": msg.date_created 
+                        })
+                        break 
+    except Exception as e:
+        st.error(f"Error fetching Twilio messages: {e}")
+    return sorted(new_messages_to_process, key=lambda m: m['timestamp_utc'])
+
+def send_whatsapp_message(twilio_client, conversation_service_sid_val, conversation_sid, message_body, bot_identity_val): # Renamed
+    """Sends a message to a Twilio Conversation from the bot's identity."""
+    if not twilio_client:
+        st.error("Twilio client not initialized for sending message.")
+        return False
+    if not conversation_service_sid_val:
+        st.error("Twilio Conversation Service SID not provided for sending message.")
+        return False
+    if not bot_identity_val:
+        st.error("Bot identity not provided for sending message.")
+        return False
+    try:
+        twilio_client.conversations.v1 \
+            .services(conversation_service_sid_val) \
+            .conversations(conversation_sid) \
+            .messages \
+            .create(author=bot_identity_val, body=message_body)
+        st.success(f"Sent reply to conversation {conversation_sid}")
+        return True
+    except Exception as e:
+        st.error(f"Error sending Twilio message to {conversation_sid}: {e}")
+        return False
+
+# --- Main Application Logic & UI ---
+st.title("🤖 RAG-Based Customer Support Chatbot")
+st.markdown("Powered by Streamlit, Twilio, GROQ LLaMA3, and FAISS.")
+
+# --- Sidebar for Configurations ---
+st.sidebar.title("⚙️ Configurations")
+
+# Use APP_ prefixed variables for values from secrets, then allow manual input if not found
+if APP_TWILIO_ACCOUNT_SID:
+    st.sidebar.text_input("Twilio Account SID (from Secrets)", value="********" + APP_TWILIO_ACCOUNT_SID[-4:] if len(APP_TWILIO_ACCOUNT_SID) > 4 else "********", disabled=True)
+    twilio_account_sid_to_use = APP_TWILIO_ACCOUNT_SID
+else:
+    st.sidebar.warning("Secret 'TWILIO_SID' not found.")
+    twilio_account_sid_to_use = st.sidebar.text_input("Twilio Account SID (Enter Manually)", value=DEFAULT_TWILIO_ACCOUNT_SID_FALLBACK, type="password")
+
+if APP_TWILIO_AUTH_TOKEN:
+    st.sidebar.text_input("Twilio Auth Token (from Secrets)", value="********", disabled=True)
+    twilio_auth_token_to_use = APP_TWILIO_AUTH_TOKEN
+else:
+    st.sidebar.warning("Secret 'TWILIO_TOKEN' not found.")
+    twilio_auth_token_to_use = st.sidebar.text_input("Twilio Auth Token (Enter Manually)", value=DEFAULT_TWILIO_AUTH_TOKEN_FALLBACK, type="password")
+
+if APP_GROQ_API_KEY:
+    st.sidebar.text_input("GROQ API Key (from Secrets)", value="gsk_********" + APP_GROQ_API_KEY[-4:] if len(APP_GROQ_API_KEY) > 8 else "********", disabled=True)
+    groq_api_key_to_use = APP_GROQ_API_KEY
+else:
+    st.sidebar.warning("Secret 'GROQ_API_KEY' not found.")
+    groq_api_key_to_use = st.sidebar.text_input("GROQ API Key (Enter Manually)", value=DEFAULT_GROQ_API_KEY_FALLBACK, type="password")
+
+# For other configurations that can be overridden if secrets not found or for user preference
+twilio_conversation_service_sid_to_use = st.sidebar.text_input(
+    "Twilio Conversation Service SID (IS...)", 
+    value=APP_TWILIO_CONVERSATION_SERVICE_SID_SECRET or DEFAULT_TWILIO_CONVERSATION_SERVICE_SID, 
+    type="password", 
+    help="The SID of your Twilio Conversations Service. Can be set by 'TWILIO_CONVERSATION_SERVICE_SID' secret."
+)
+twilio_bot_whatsapp_identity_to_use = st.sidebar.text_input(
+    "Twilio Bot WhatsApp Identity", 
+    value=APP_TWILIO_BOT_WHATSAPP_IDENTITY_SECRET or DEFAULT_TWILIO_BOT_WHATSAPP_IDENTITY,
+    help="e.g., 'whatsapp:+1234567890'. Can be set by 'TWILIO_BOT_WHATSAPP_IDENTITY' secret."
+)
+embedding_model_name_to_use = st.sidebar.text_input( # Renamed
+    "Embedding Model Name", 
+    value=DEFAULT_EMBEDDING_MODEL_NAME
+)
+polling_interval_to_use = st.sidebar.number_input( # Renamed
+    "Twilio Polling Interval (seconds)", 
+    min_value=10, max_value=300, 
+    value=DEFAULT_POLLING_INTERVAL_S, 
+    step=5
+)
 
+# --- Initialize Session State ---
+if "app_started" not in st.session_state: st.session_state.app_started = False
+if "bot_started" not in st.session_state: st.session_state.bot_started = False
+if "rag_pipeline_ready" not in st.session_state: st.session_state.rag_pipeline_ready = False
+if "last_twilio_poll_time" not in st.session_state: st.session_state.last_twilio_poll_time = time.time()
+if "bot_start_time_utc" not in st.session_state: st.session_state.bot_start_time_utc = None
+if "processed_message_sids" not in st.session_state: st.session_state.processed_message_sids = set()
+if "manual_chat_history" not in st.session_state: st.session_state.manual_chat_history = []
+
+# --- Helper: Simple Intent Classifier ---
+def simple_intent_classifier(query):
+    query_lower = query.lower()
+    if any(k in query_lower for k in ["order", "status", "track", "delivery"]): return "ORDER_STATUS"
+    if any(k in query_lower for k in ["product", "item", "buy", "price", "feature", "stock"]): return "PRODUCT_INFO"
+    if any(k in query_lower for k in ["return", "policy", "refund", "exchange", "faq", "question", "how to", "support"]): return "GENERAL_POLICY_FAQ"
+    return "UNKNOWN"
+
+# --- Main Application Controls ---
+col1, col2, col3, col4 = st.columns(4)
+with col1:
+    if st.button("🚀 Start App", disabled=st.session_state.app_started, use_container_width=True):
+        if not groq_api_key_to_use: # Use the correct variable
+            st.error("GROQ API Key is required.")
+        else:
+            with st.spinner("Initializing RAG pipeline..."):
+                st.session_state.embedding_model = initialize_embedding_model(embedding_model_name_to_use) # Use correct var
+                st.session_state.customer_orders_data = load_json_data(CUSTOMER_ORDERS_FILE)
+                st.session_state.products_data = load_json_data(PRODUCTS_FILE)
+                policy_pdf_pages = load_pdf_data(POLICY_PDF_FILE)
+                faq_pdf_pages = load_pdf_data(FAQ_PDF_FILE)
+                all_pdf_text_pages = policy_pdf_pages + faq_pdf_pages
+                st.session_state.pdf_text_chunks_raw = chunk_text(all_pdf_text_pages)
+
+                if st.session_state.embedding_model and st.session_state.pdf_text_chunks_raw:
+                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = \
+                        create_faiss_index(st.session_state.pdf_text_chunks_raw, st.session_state.embedding_model)
+                else:
+                    st.session_state.faiss_index_pdfs, st.session_state.indexed_pdf_chunks = None, []
+                    st.warning("FAISS index for PDFs could not be created.")
+                
+                st.session_state.groq_client = initialize_groq_client(groq_api_key_to_use) # Use correct var
+
+                if st.session_state.embedding_model and st.session_state.groq_client and \
+                   st.session_state.customer_orders_data and st.session_state.products_data:
+                    st.session_state.rag_pipeline_ready = True
+                    st.session_state.app_started = True
+                    st.success("RAG Application Started!")
+                    st.rerun()
+                else:
+                    st.error("Failed to initialize RAG pipeline. Check configurations and ensure all data files are present in 'docs/'.")
+                    st.session_state.app_started = False
+with col2:
+    if st.button("🛑 Stop App", disabled=not st.session_state.app_started, use_container_width=True):
+        keys_to_reset = ["app_started", "bot_started", "rag_pipeline_ready", "embedding_model", 
+                         "customer_orders_data", "products_data", "pdf_text_chunks_raw", 
+                         "faiss_index_pdfs", "indexed_pdf_chunks", "groq_client", "twilio_client", 
+                         "bot_start_time_utc", "processed_message_sids", "manual_chat_history"]
+        for key in keys_to_reset:
+            if key in st.session_state: del st.session_state[key]
+        st.session_state.app_started = False
+        st.session_state.bot_started = False
+        st.session_state.rag_pipeline_ready = False
+        st.session_state.processed_message_sids = set()
+        st.session_state.manual_chat_history = []
+        st.success("Application Stopped.")
+        st.rerun()
+with col3:
+    if st.button("💬 Start WhatsApp Bot", disabled=not st.session_state.app_started or st.session_state.bot_started, use_container_width=True):
+        if not all([twilio_account_sid_to_use, twilio_auth_token_to_use, twilio_conversation_service_sid_to_use, twilio_bot_whatsapp_identity_to_use]): # Use correct vars
+            st.error("Twilio credentials, Service SID, and Bot Identity are required.")
+        else:
+            st.session_state.twilio_client = initialize_twilio_client(twilio_account_sid_to_use, twilio_auth_token_to_use) # Use correct vars
+            if st.session_state.twilio_client:
+                st.session_state.bot_started = True
+                st.session_state.bot_start_time_utc = datetime.now(timezone.utc)
+                st.session_state.processed_message_sids = set()
+                st.session_state.last_twilio_poll_time = time.time() - polling_interval_to_use -1 # Use correct var
+                st.success("WhatsApp Bot Started!")
+                st.rerun()
+            else:
+                st.error("Failed to initialize Twilio client.")
+with col4:
+    if st.button("🔕 Stop WhatsApp Bot", disabled=not st.session_state.bot_started, use_container_width=True):
+        st.session_state.bot_started = False
+        st.info("WhatsApp Bot Stopped.")
+        st.rerun()
+st.divider()
+
+# --- Manual Query Interface ---
+if st.session_state.get("app_started") and st.session_state.get("rag_pipeline_ready"):
+    st.subheader("💬 Manual Query")
+    for chat_entry in st.session_state.manual_chat_history:
+        with st.chat_message(chat_entry["role"]):
+            st.markdown(chat_entry["content"])
+            if "context" in chat_entry and chat_entry["context"]:
+                 with st.expander("Retrieved Context"): st.json(chat_entry["context"])
+
+    user_query_manual = st.chat_input("Ask a question:")
+    if user_query_manual:
+        st.session_state.manual_chat_history.append({"role": "user", "content": user_query_manual})
+        with st.chat_message("user"): st.markdown(user_query_manual)
+
+        with st.spinner("Thinking..."):
+            intent = simple_intent_classifier(user_query_manual)
+            context_for_llm, raw_context_data = "No specific context.", None
+
+            if intent == "ORDER_STATUS":
+                words = user_query_manual.split()
+                potential_oid = next((w for w in words if w.upper().startswith("ORD")), None)
+                if potential_oid:
+                    raw_context_data = get_order_details(potential_oid.upper(), st.session_state.customer_orders_data)
+                    context_for_llm = f"Order Details: {raw_context_data}"
+                else:
+                    context_for_llm = "Please provide an Order ID."
+                    raw_context_data = {"message": "Order ID needed."}
+            elif intent == "PRODUCT_INFO":
+                raw_context_data = get_product_info(user_query_manual, st.session_state.products_data)
+                context_for_llm = f"Product Information: {raw_context_data}"
+            elif intent == "GENERAL_POLICY_FAQ" or intent == "UNKNOWN": 
+                if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
+                    k_val = 2 if intent == "GENERAL_POLICY_FAQ" else 1
+                    retrieved_chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_manual, 
+                                                          st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
+                    if retrieved_chunks:
+                        context_for_llm = "\n\n".join(retrieved_chunks)
+                        raw_context_data = retrieved_chunks
+                    else:
+                        context_for_llm = "No specific policy/FAQ info found." if intent == "GENERAL_POLICY_FAQ" else "Could not find relevant info."
+                        raw_context_data = {"message": "No relevant PDF chunks found."}
+                else:
+                    context_for_llm = "Policy/FAQ documents unavailable."
+                    raw_context_data = {"message": "PDF index not ready."}
+            
+            llm_response = generate_response_groq(st.session_state.groq_client, user_query_manual, context_for_llm)
+            with st.chat_message("assistant"):
+                st.markdown(llm_response)
+                if raw_context_data:
+                    with st.expander("Retrieved Context"):
+                        try:
+                            if isinstance(raw_context_data, str) and (raw_context_data.strip().startswith('{') or raw_context_data.strip().startswith('[')):
+                                st.json(json.loads(raw_context_data))
+                            else: st.json(raw_context_data) 
+                        except (json.JSONDecodeError, TypeError): st.text(str(raw_context_data))
+            st.session_state.manual_chat_history.append({"role": "assistant", "content": llm_response, "context": raw_context_data})
+
+# --- Twilio Bot Polling Logic ---
+if st.session_state.get("bot_started") and st.session_state.get("rag_pipeline_ready"):
+    current_time = time.time()
+    if (current_time - st.session_state.get("last_twilio_poll_time", 0)) > polling_interval_to_use: # Use correct var
+        st.session_state.last_twilio_poll_time = current_time
+        with st.spinner("Checking WhatsApp messages..."):
+            if not st.session_state.get("twilio_client") or not twilio_conversation_service_sid_to_use or not twilio_bot_whatsapp_identity_to_use: # Use correct vars
+                st.warning("Twilio client/config missing for polling.")
+            else:
+                new_messages = get_new_whatsapp_messages(st.session_state.twilio_client, twilio_conversation_service_sid_to_use, 
+                                                         st.session_state.bot_start_time_utc, st.session_state.processed_message_sids,
+                                                         twilio_bot_whatsapp_identity_to_use) # Use correct vars
+                if new_messages:
+                    st.info(f"Found {len(new_messages)} new WhatsApp message(s).")
+                    for msg_data in new_messages:
+                        user_query_whatsapp, conv_sid, msg_sid, author_id = msg_data["message_body"], msg_data["conversation_sid"], msg_data["message_sid"], msg_data["author_identity"]
+                        st.write(f"Processing from {author_id} in {conv_sid}: '{user_query_whatsapp}'")
+
+                        intent = simple_intent_classifier(user_query_whatsapp)
+                        context_whatsapp = "No specific context."
+                        if intent == "ORDER_STATUS":
+                            words = user_query_whatsapp.split()
+                            oid = next((w for w in words if w.upper().startswith("ORD")), None)
+                            context_whatsapp = f"Order Details: {get_order_details(oid.upper(), st.session_state.customer_orders_data)}" if oid else "Please provide Order ID."
+                        elif intent == "PRODUCT_INFO":
+                            context_whatsapp = f"Product Info: {get_product_info(user_query_whatsapp, st.session_state.products_data)}"
+                        elif intent == "GENERAL_POLICY_FAQ" or intent == "UNKNOWN":
+                            if st.session_state.faiss_index_pdfs and st.session_state.embedding_model:
+                                k_val = 2 if intent == "GENERAL_POLICY_FAQ" else 1
+                                chunks = search_faiss_index(st.session_state.faiss_index_pdfs, user_query_whatsapp, st.session_state.embedding_model, st.session_state.indexed_pdf_chunks, k=k_val)
+                                context_whatsapp = "\n\n".join(chunks) if chunks else ("No policy/FAQ info." if intent == "GENERAL_POLICY_FAQ" else "No relevant info.")
+                            else: context_whatsapp = "Policy/FAQ docs unavailable."
+                        
+                        response_whatsapp = generate_response_groq(st.session_state.groq_client, user_query_whatsapp, context_whatsapp)
+                        if send_whatsapp_message(st.session_state.twilio_client, twilio_conversation_service_sid_to_use, conv_sid, response_whatsapp, twilio_bot_whatsapp_identity_to_use): # Use correct vars
+                            st.session_state.processed_message_sids.add(msg_sid)
+                            st.success(f"Responded to {msg_sid} from {author_id}")
+                        else: st.error(f"Failed to send response for {msg_sid}")
+                    st.experimental_rerun()
+
+# --- Footer & Status ---
+st.sidebar.markdown("---")
+st.sidebar.info("Ensure all keys and SIDs are correctly configured. Primary API keys (Twilio SID/Token, GROQ Key) are loaded from secrets if available.")
+if st.session_state.get("app_started"):
+    st.sidebar.success(f"App RUNNING. WhatsApp Bot {'RUNNING' if st.session_state.get('bot_started') else 'STOPPED'}.")
+else:
+    st.sidebar.warning("App is STOPPED.")
 
-if __name__ == "__main__":
-    main()