initial commit

.gitignore

@@ -0,0 +1,3 @@
+# Ignore all files in the .venv directory
+venv
+__pycache__

README.md

@@ -1,12 +1,100 @@
----
-title: Faq Rag Chatbot
-emoji: 🌖
-colorFrom: yellow
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.44.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FAQ Chatbot Using RAG for Customer Support - Setup Instructions
+
+Follow these steps to set up and run the e-commerce FAQ chatbot, optimized for hardware with 16-19GB RAM and 8-11GB GPU.
+
+## Prerequisites
+
+- Python 3.8 or higher
+- CUDA-compatible GPU with 8-11GB VRAM
+- 16-19GB RAM
+- Internet connection (for downloading models and datasets)
+
+## Step 1: Create Project Directory Structure
+
+```bash
+# Create the project directory
+mkdir faq-rag-chatbot
+cd faq-rag-chatbot
+
+# Create the source directory
+mkdir -p src data
+```
+
+## Step 2: Create Virtual Environment
+
+```bash
+# Create a virtual environment
+python -m venv venv
+
+# Activate the virtual environment
+# On Windows:
+venv\Scripts\activate
+# On macOS/Linux:
+source venv/bin/activate
+```
+
+## Step 3: Create Project Files
+
+Create all the required files with the optimized code provided:
+
+1. `requirements.txt`
+2. `src/__init__.py`
+3. `src/data_processing.py`
+4. `src/embedding.py`
+5. `src/llm_response.py`
+6. `src/utils.py`
+7. `app.py`
+
+## Step 4: Install Dependencies
+
+```bash
+# Install required packages
+pip install -r requirements.txt
+
+# Additional dependency for memory monitoring
+pip install psutil
+```
+
+## Step 5: Run the Application
+
+```bash
+# Make sure the virtual environment is activated
+# Run the Streamlit app
+streamlit run app.py
+```
+
+## Memory Optimization Notes
+
+This implementation includes several optimizations for systems with 16-19GB RAM and 8-11GB GPU:
+
+1. **Default to Smaller Models**: The app defaults to Phi-2 which works well on 8GB GPUs
+2. **4-bit Quantization**: Uses 4-bit quantization for larger models like Mistral-7B
+3. **Memory Offloading**: Offloads weights to CPU when not in use
+4. **Batch Processing**: Processes embeddings in smaller batches
+5. **Garbage Collection**: Aggressively frees memory after operations
+6. **Response Length Limits**: Generates shorter responses to save memory
+7. **CPU Embedding**: Keeps the embedding model on CPU to save GPU memory for the LLM
+
+## Using the Chatbot
+
+1. The application will automatically download the e-commerce FAQ dataset from Hugging Face
+2. Choose an appropriate model based on your available GPU memory:
+   - For 8GB GPU: Use Phi-2 (default)
+   - For 10-11GB GPU: You can try Mistral-7B with 4-bit quantization
+   - For limited GPU or CPU-only: Use TinyLlama-1.1B
+3. Type a question or select a sample question
+4. The system will retrieve relevant FAQs and generate a response
+5. Monitor memory usage in the sidebar
+
+## Troubleshooting
+
+- **Out of Memory Errors**: If you encounter CUDA out of memory errors, switch to a smaller model like TinyLlama-1.1B
+- **Slow Response Times**: First response may be slow as the model loads, subsequent responses will be faster
+- **Model Loading Issues**: If Mistral-7B fails to load, the system will automatically fall back to Phi-2
+
+## Performance Considerations
+
+- The embedding and retrieval components work efficiently even on limited hardware
+- Response generation speed depends on the model size and available GPU memory
+- For optimal performance with 8GB GPU, stick with Phi-2 model
+- For faster responses with less accuracy, use TinyLlama-1.1B

app.py

@@ -0,0 +1,235 @@
+import streamlit as st
+import time
+import os
+import gc
+import torch
+from src.data_processing import load_huggingface_faq_data, load_faq_data, preprocess_faq
+from src.embedding import FAQEmbedder
+from src.llm_response import ResponseGenerator
+from src.utils import time_function, format_memory_stats
+
+# Set page title and layout
+st.set_page_config(
+    page_title="E-Commerce FAQ Chatbot",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Memory optimization: Force garbage collection before starting
+gc.collect()
+if torch.cuda.is_available():
+    torch.cuda.empty_cache()
+
+@time_function
+def initialize_components(use_huggingface: bool = True, model_name: str = "mistralai/Mistral-7B-Instruct-v0.1"):
+    """Initialize all components of the RAG system with memory optimization"""
+    
+    # Step 1: Load and preprocess FAQ data
+    if use_huggingface:
+        faqs = load_huggingface_faq_data("NebulaByte/E-Commerce_FAQs")
+    else:
+        data_path = os.path.join("data", "faq_data.csv")
+        faqs = load_faq_data(data_path)
+    
+    processed_faqs = preprocess_faq(faqs)
+    
+    # Step 2: Initialize and create embeddings
+    # Use smaller batch size for memory efficiency
+    embedder = FAQEmbedder()
+    embedder.create_embeddings(processed_faqs, batch_size=32)
+    
+    # Clear memory before loading the LLM
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+    
+    # Step 3: Initialize response generator
+    response_generator = ResponseGenerator(model_name=model_name)
+    
+    return embedder, response_generator, len(processed_faqs)
+
+def main():
+    st.title("E-Commerce Customer Support FAQ Chatbot")
+    st.subheader("Ask any question about your orders, shipping, returns, or any other e-commerce related queries")
+    
+    # Sidebar configuration
+    st.sidebar.title("Configuration")
+    use_huggingface = st.sidebar.checkbox("Use Hugging Face Dataset", value=True)
+    
+    # Model options - include smaller models by default
+    model_options = {
+        "Phi-2 (Recommended for 8GB GPU)": "microsoft/phi-2",
+        "TinyLlama-1.1B (Smallest, fastest)": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        "Mistral-7B (Requires 4-bit quantization)": "mistralai/Mistral-7B-Instruct-v0.1"
+    }
+    
+    # Default to Phi-2 for 8-11GB GPU
+    selected_model = st.sidebar.selectbox("Select LLM Model", list(model_options.keys()), index=0)
+    model_name = model_options[selected_model]
+    
+    # Memory usage monitoring
+    if st.sidebar.checkbox("Show Memory Usage", value=True):
+        st.sidebar.subheader("Memory Usage")
+        memory_stats = format_memory_stats()
+        for key, value in memory_stats.items():
+            st.sidebar.text(f"{key}: {value}")
+    
+    # Initialize session state for chat history if it doesn't exist
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    
+    # Initialize RAG components (only once)
+    if "system_initialized" not in st.session_state or st.sidebar.button("Reload System"):
+        with st.spinner("Initializing system components... This may take a few minutes."):
+            st.session_state.embedder, st.session_state.response_generator, num_faqs = initialize_components(
+                use_huggingface=use_huggingface,
+                model_name=model_name
+            )
+            st.session_state.system_initialized = True
+            st.sidebar.success(f"System initialized with {num_faqs} FAQs!")
+    
+    # Chat interface
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        # Display chat history
+        st.subheader("Conversation")
+        chat_container = st.container(height=400)
+        
+        with chat_container:
+            for i, message in enumerate(st.session_state.chat_history):
+                if message["role"] == "user":
+                    st.markdown(f"**You**: {message['content']}")
+                else:
+                    st.markdown(f"**Bot**: {message['content']}")
+                
+                if i < len(st.session_state.chat_history) - 1:
+                    st.markdown("---")
+    
+        # Chat input
+        with st.form(key="chat_form"):
+            user_query = st.text_input("Type your question:", key="user_input", 
+                                       placeholder="e.g., How do I track my order?")
+            submit_button = st.form_submit_button("Ask")
+    
+    with col2:
+        if st.session_state.get("system_initialized", False):
+            # Show FAQ metadata and information
+            st.subheader("Retrieved Information")
+            info_container = st.container(height=500)
+            
+            with info_container:
+                if "current_faqs" in st.session_state:
+                    for i, faq in enumerate(st.session_state.get("current_faqs", [])):
+                        st.markdown(f"**Relevant FAQ #{i+1}**")
+                        st.markdown(f"**Q**: {faq['question']}")
+                        # Limit answer length to save UI memory
+                        st.markdown(f"**A**: {faq['answer'][:150]}..." if len(faq['answer']) > 150 else f"**A**: {faq['answer']}")
+                        st.markdown(f"*Similarity Score*: {faq['similarity']:.2f}")
+                        if 'category' in faq and faq['category']:
+                            st.markdown(f"*Category*: {faq['category']}")
+                        st.markdown("---")
+                else:
+                    st.markdown("Ask a question to see relevant FAQs here.")
+    
+    # Performance metrics in the sidebar
+    if "retrieval_time" in st.session_state and "generation_time" in st.session_state:
+        st.sidebar.subheader("Performance Metrics")
+        st.sidebar.markdown(f"Retrieval time: {st.session_state.retrieval_time:.2f} seconds")
+        st.sidebar.markdown(f"Response generation: {st.session_state.generation_time:.2f} seconds")
+        st.sidebar.markdown(f"Total time: {st.session_state.retrieval_time + st.session_state.generation_time:.2f} seconds")
+    
+    # Process user query
+    if submit_button and user_query:
+        # Add user query to chat history
+        st.session_state.chat_history.append({"role": "user", "content": user_query})
+        
+        # Process query
+        with st.spinner("Thinking..."):
+            # Free memory before processing
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+                
+            # Step 1: Retrieve relevant FAQs
+            start_time = time.time()
+            relevant_faqs = st.session_state.embedder.retrieve_relevant_faqs(user_query)
+            retrieval_time = time.time() - start_time
+            
+            # Step 2: Generate response
+            start_time = time.time()
+            response = st.session_state.response_generator.generate_response(user_query, relevant_faqs)
+            generation_time = time.time() - start_time
+            
+            # Store metrics and retrieved FAQs
+            st.session_state.retrieval_time = retrieval_time
+            st.session_state.generation_time = generation_time
+            st.session_state.current_faqs = relevant_faqs
+            
+            # Step 3: Add response to chat history
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+            
+            # Free memory after processing
+            gc.collect()
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+        
+        # Rerun to display the updated chat history
+        st.experimental_rerun()
+    
+    # Add sample questions at the bottom
+    st.subheader("Sample Questions")
+    sample_questions = [
+        "How do I track my order?",
+        "What should I do if my delivery is delayed?",
+        "How do I return a product?",
+        "Can I cancel my order after placing it?",
+        "How quickly will my order be delivered?",
+        "Why can't I track my order yet?"
+    ]
+    
+    # Use two columns instead of three to reduce memory usage
+    cols = st.columns(2)
+    for i, question in enumerate(sample_questions):
+        col_idx = i % 2
+        if cols[col_idx].button(question, key=f"sample_{i}"):
+            # Clear the text input and set the sample question
+            st.session_state.user_input = question
+            # Simulate form submission
+            st.session_state.chat_history.append({"role": "user", "content": question})
+            
+            # Process query (similar to above)
+            with st.spinner("Thinking..."):
+                # Free memory before processing
+                gc.collect()
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+                    
+                # Step 1: Retrieve relevant FAQs
+                start_time = time.time()
+                relevant_faqs = st.session_state.embedder.retrieve_relevant_faqs(question)
+                retrieval_time = time.time() - start_time
+                
+                # Step 2: Generate response
+                start_time = time.time()
+                response = st.session_state.response_generator.generate_response(question, relevant_faqs)
+                generation_time = time.time() - start_time
+                
+                # Store metrics and retrieved FAQs
+                st.session_state.retrieval_time = retrieval_time
+                st.session_state.generation_time = generation_time
+                st.session_state.current_faqs = relevant_faqs
+                
+                # Step 3: Add response to chat history
+                st.session_state.chat_history.append({"role": "assistant", "content": response})
+                
+                # Free memory after processing
+                gc.collect()
+                if torch.cuda.is_available():
+                    torch.cuda.empty_cache()
+            
+            # Rerun to display the updated chat history
+            st.experimental_rerun()
+
+if __name__ == "__main__":
+    main()

data/faq_data.csv

@@ -0,0 +1,11 @@
+question,answer
+"How do I reset my password?","To reset your password, click on the 'Forgot Password' link on the login page. You'll receive an email with instructions to set a new password."
+"What payment methods do you accept?","We accept Visa, Mastercard, American Express, and PayPal. All payments are processed securely through our payment gateway."
+"How do I track my order?","You can track your order by logging into your account and visiting the 'Order History' section. Click on the specific order to see its current status and tracking information."
+"What is your return policy?","Our return policy allows returns within 30 days of purchase. Items must be in original condition with tags attached. Please fill out the return form in your order confirmation email to start the process."
+"How long does shipping take?","Standard shipping typically takes 3-5 business days within the continental US. Express shipping (1-2 business days) is available for an additional fee. International shipping times vary by destination."
+"Do you offer international shipping?","Yes, we ship to most countries worldwide. International shipping costs and delivery times vary based on the destination. You can see the specific shipping options during checkout."
+"How do I cancel my subscription?","To cancel your subscription, log in to your account, go to 'Subscription Settings', and click on 'Cancel Subscription'. Follow the prompts to complete the cancellation process."
+"Is my personal information secure?","Yes, we take data security seriously. We use industry-standard encryption protocols to protect your personal information. We never share your data with third parties without your consent."
+"How do I contact customer support?","You can contact our customer support team via email at support@example.com, through the live chat on our website, or by calling our support line at 1-800-123-4567 during business hours (9 AM - 5 PM EST, Monday-Friday)."
+"Do you offer discounts for bulk orders?","Yes, we offer volume discounts for bulk orders. Please contact our sales team at sales@example.com with your requirements to get a custom quote."

notes.txt

@@ -0,0 +1,16 @@
+# Create a virtual environment (recommended)
+python -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install required packages
+pip install torch transformers sentence-transformers faiss-cpu pandas streamlit nltk
+
+
+
+
+
+# Activate your virtual environment if not already active
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Run the Streamlit app
+streamlit run app.py

requirements.txt

@@ -0,0 +1,10 @@
+torch>=2.0.0
+transformers>=4.30.0
+sentence-transformers>=2.2.2
+faiss-cpu>=1.7.4
+pandas>=1.5.0
+streamlit>=1.25.0
+numpy>=1.24.0
+datasets>=2.10.0
+bitsandbytes>=0.40.0
+accelerate>=0.20.0

src/__init__.py

@@ -0,0 +1,2 @@
+
+# This file is intentionally left empty to mark the directory as a Python package

src/data_processing.py

@@ -0,0 +1,93 @@
+import pandas as pd
+import json
+from typing import List, Dict, Any
+from datasets import load_dataset
+
+def load_huggingface_faq_data(dataset_name: str = "NebulaByte/E-Commerce_FAQs") -> List[Dict[str, Any]]:
+    """
+    Load FAQ data from Hugging Face datasets
+    """
+    print(f"Loading dataset {dataset_name} from Hugging Face...")
+    
+    try:
+        # Load the dataset
+        dataset = load_dataset(dataset_name)
+        
+        # Get the train split (as seen in the screenshots)
+        train_data = dataset["train"]
+        
+        # Convert to list of dictionaries
+        faqs = []
+        for item in train_data:
+            # Extract the required fields
+            faq = {
+                "question": item["question"],
+                "answer": item["answer"],
+                # Include additional metadata
+                "category": item.get("category", ""),
+                "question_id": item.get("question_id", ""),
+                "faq_url": item.get("faq_url", "")
+            }
+            faqs.append(faq)
+        
+        print(f"Loaded {len(faqs)} FAQ entries from Hugging Face")
+        return faqs
+    
+    except Exception as e:
+        print(f"Error loading dataset from Hugging Face: {e}")
+        print("Falling back to local data...")
+        return load_faq_data("data/faq_data.csv")
+
+def load_faq_data(file_path: str) -> List[Dict[str, Any]]:
+    """
+    Load FAQ data from a local CSV or JSON file
+    """
+    print(f"Loading data from {file_path}")
+    try:
+        if file_path.endswith('.csv'):
+            df = pd.read_csv(file_path)
+            # Assume CSV has 'question' and 'answer' columns
+            faqs = df.to_dict('records')
+        elif file_path.endswith('.json'):
+            with open(file_path, 'r') as f:
+                faqs = json.load(f)
+        else:
+            raise ValueError(f"Unsupported file format: {file_path}")
+        
+        print(f"Loaded {len(faqs)} FAQ entries")
+        return faqs
+    except Exception as e:
+        print(f"Error loading data: {e}")
+        # Create a minimal sample dataset as fallback
+        print("Creating sample dataset as fallback")
+        sample_faqs = [
+            {"question": "How do I track my order?", 
+             "answer": "You can track your order by logging into your account and visiting the Order History section."},
+            {"question": "How do I reset my password?", 
+             "answer": "To reset your password, click on the 'Forgot Password' link on the login page."}
+        ]
+        return sample_faqs
+
+def preprocess_faq(faqs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Preprocess FAQ data: clean text, handle formatting
+    """
+    processed_faqs = []
+    for faq in faqs:
+        # Basic cleaning - remove extra whitespace
+        if 'question' in faq and faq['question'] is not None:
+            faq['question'] = faq['question'].strip()
+        else:
+            faq['question'] = ""
+            
+        if 'answer' in faq and faq['answer'] is not None:
+            faq['answer'] = faq['answer'].strip()
+        else:
+            faq['answer'] = ""
+        
+        # Only include FAQs with both question and answer
+        if faq.get('question') and faq.get('answer'):
+            processed_faqs.append(faq)
+    
+    print(f"After preprocessing: {len(processed_faqs)} valid FAQ entries")
+    return processed_faqs

src/embedding.py

@@ -0,0 +1,81 @@
+from sentence_transformers import SentenceTransformer
+import faiss
+import numpy as np
+from typing import List, Dict, Any
+import torch
+import gc
+
+class FAQEmbedder:
+    def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
+        """
+        Initialize the FAQ embedder with a sentence transformer model
+        Optimized for memory efficiency
+        """
+        print(f"Initializing FAQ Embedder with model: {model_name}")
+        # Use CPU for embedding model to save GPU memory for LLM
+        self.device = "cpu"
+        self.model = SentenceTransformer(model_name, device=self.device)
+        self.index = None
+        self.faqs = None
+        self.embeddings = None
+    
+    def create_embeddings(self, faqs: List[Dict[str, Any]], batch_size: int = 32) -> None:
+        """
+        Create embeddings for all FAQs and build FAISS index
+        Using batching for memory efficiency
+        """
+        self.faqs = faqs
+        print(f"Creating embeddings for {len(faqs)} FAQs in batches of {batch_size}...")
+        
+        # Extract questions for embedding
+        questions = [faq['question'] for faq in faqs]
+        
+        # Process in batches to reduce memory usage
+        all_embeddings = []
+        for i in range(0, len(questions), batch_size):
+            batch = questions[i:i+batch_size]
+            print(f"Processing batch {i//batch_size + 1}/{(len(questions) + batch_size - 1)//batch_size}")
+            
+            # Create embeddings for this batch
+            batch_embeddings = self.model.encode(batch, show_progress_bar=False, convert_to_numpy=True)
+            all_embeddings.append(batch_embeddings)
+            
+        # Combine all batches
+        self.embeddings = np.vstack(all_embeddings).astype('float32')
+        
+        # Clear memory explicitly
+        all_embeddings = None
+        gc.collect()
+        
+        # Create FAISS index
+        dimension = self.embeddings.shape[1]
+        self.index = faiss.IndexFlatL2(dimension)
+        self.index.add(self.embeddings)
+        
+        print(f"Created embeddings of shape {self.embeddings.shape}")
+        print(f"FAISS index contains {self.index.ntotal} vectors")
+    
+    def retrieve_relevant_faqs(self, query: str, k: int = 3) -> List[Dict[str, Any]]:
+        """
+        Retrieve top-k relevant FAQs for a given query
+        """
+        if self.index is None or self.faqs is None or self.embeddings is None:
+            raise ValueError("Embeddings not created yet. Call create_embeddings first.")
+        
+        # Embed the query
+        query_embedding = self.model.encode([query], convert_to_numpy=True).astype('float32')
+        
+        # Search in FAISS
+        distances, indices = self.index.search(query_embedding, k)
+        
+        # Get the relevant FAQs with their similarity scores
+        relevant_faqs = []
+        for i, idx in enumerate(indices[0]):
+            if idx < len(self.faqs):  # Ensure index is valid
+                faq = self.faqs[idx].copy()
+                # Convert L2 distance to similarity score (higher is better)
+                similarity = 1.0 / (1.0 + distances[0][i])
+                faq['similarity'] = similarity
+                relevant_faqs.append(faq)
+        
+        return relevant_faqs

src/llm_response.py

@@ -0,0 +1,138 @@
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+import torch
+from typing import List, Dict, Any
+import gc
+
+class ResponseGenerator:
+    def __init__(self, model_name: str = "mistralai/Mistral-7B-Instruct-v0.1"):
+        """
+        Initialize the response generator with an LLM
+        Optimized for 8-11GB GPU
+        """
+        print(f"Loading LLM: {model_name}")
+        print("This may take a few minutes...")
+        
+        # Load tokenizer
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        
+        # Configure device and data type based on available resources
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {device}")
+        
+        # Free up memory before loading model
+        gc.collect()
+        if device == "cuda":
+            torch.cuda.empty_cache()
+        
+        # Configure 4-bit quantization for maximum memory efficiency
+        try:
+            # Use 4-bit quantization for models that support it
+            quantization_config = BitsAndBytesConfig(
+                load_in_4bit=True,
+                bnb_4bit_compute_dtype=torch.float16,
+                bnb_4bit_use_double_quant=True,
+                bnb_4bit_quant_type="nf4"
+            )
+            
+            # Load the model with quantization
+            self.model = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                quantization_config=quantization_config,
+                device_map="auto",
+                torch_dtype=torch.float16,
+                # Load model in parts to avoid OOM errors
+                max_memory={0: "8GiB", "cpu": "16GiB"},
+                offload_folder="offload",
+                offload_state_dict=True,  # Offload weights to CPU when not in use
+                low_cpu_mem_usage=True
+            )
+        except Exception as e:
+            print(f"4-bit quantization error: {e}")
+            print("Falling back to 8-bit quantization...")
+            
+            try:
+                # Try 8-bit quantization
+                quantization_config = BitsAndBytesConfig(
+                    load_in_8bit=True,
+                    bnb_8bit_use_double_quant=True
+                )
+                
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    model_name,
+                    quantization_config=quantization_config,
+                    device_map="auto",
+                    torch_dtype=torch.float16,
+                    max_memory={0: "8GiB", "cpu": "16GiB"},
+                    offload_folder="offload",
+                    low_cpu_mem_usage=True
+                )
+            except Exception as e2:
+                print(f"8-bit quantization error: {e2}")
+                print("Falling back to smaller model...")
+                
+                # Use a much smaller model as fallback
+                backup_model = "microsoft/phi-2"
+                self.tokenizer = AutoTokenizer.from_pretrained(backup_model)
+                self.model = AutoModelForCausalLM.from_pretrained(
+                    backup_model,
+                    device_map="auto",
+                    torch_dtype=torch.float16 if device == "cuda" else torch.float32
+                )
+        
+        print("LLM loaded successfully")
+    
+    def generate_response(self, query: str, relevant_faqs: List[Dict[str, Any]]) -> str:
+        """
+        Generate a response using the LLM with retrieved FAQs as context
+        Memory-optimized version
+        """
+        # Create prompt with relevant FAQs
+        prompt = self._create_prompt(query, relevant_faqs)
+        
+        # Generate response with memory-efficient settings
+        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
+        
+        with torch.no_grad():
+            # Use more conservative generation parameters
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=200,  # Shorter response for memory efficiency
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+        
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Extract just the response part (after the prompt)
+        response = response[len(prompt):].strip()
+        
+        # Clear GPU memory after generating response
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        
+        return response
+    
+    def _create_prompt(self, query: str, relevant_faqs: List[Dict[str, Any]]) -> str:
+        """
+        Create a prompt for the LLM with retrieved FAQs as context
+        """
+        # Format FAQs in a way that's suitable for the model
+        faq_context = "\n\n".join([
+            f"Q: {faq['question']}\nA: {faq['answer']}" 
+            for faq in relevant_faqs
+        ])
+        
+        # Create the prompt
+        prompt = f"""
+Below are some relevant e-commerce customer support FAQ entries:
+
+{faq_context}
+
+Based on the information above, please provide a helpful, accurate, and concise response to the following customer query:
+Customer Query: {query}
+
+Response:
+"""
+        return prompt

src/utils.py

@@ -0,0 +1,59 @@
+import time
+import functools
+from typing import Callable, Any, Dict
+
+def time_function(func: Callable) -> Callable:
+    """
+    Decorator to time function execution
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        print(f"{func.__name__} took {end_time - start_time:.2f} seconds to execute")
+        return result
+    return wrapper
+
+def evaluate_response(generated_response: str, ground_truth: str = None) -> Dict[str, Any]:
+    """
+    Basic evaluation of generated response
+    """
+    results = {
+        "length": len(generated_response),
+        "word_count": len(generated_response.split())
+    }
+    
+    # If ground truth is provided, we could add metrics like BLEU or ROUGE
+    if ground_truth:
+        # Simplified evaluation - word overlap
+        generated_words = set(generated_response.lower().split())
+        ground_truth_words = set(ground_truth.lower().split())
+        overlap = len(generated_words.intersection(ground_truth_words))
+        results["word_overlap"] = overlap / len(ground_truth_words) if ground_truth_words else 0
+    
+    return results
+
+def format_memory_stats():
+    """
+    Format memory usage statistics for display
+    """
+    import torch
+    import psutil
+    import os
+    
+    # System memory
+    system_stats = {
+        "RAM": f"{psutil.virtual_memory().used / (1024 ** 3):.1f}GB / {psutil.virtual_memory().total / (1024 ** 3):.1f}GB",
+        "RAM Usage": f"{psutil.virtual_memory().percent}%",
+    }
+    
+    # GPU memory if available
+    if torch.cuda.is_available():
+        gpu_stats = {}
+        for i in range(torch.cuda.device_count()):
+            gpu_stats[f"GPU {i}"] = f"{torch.cuda.get_device_name(i)}"
+            gpu_stats[f"GPU {i} Memory"] = f"{torch.cuda.memory_allocated(i) / (1024 ** 3):.1f}GB / {torch.cuda.get_device_properties(i).total_memory / (1024 ** 3):.1f}GB"
+        system_stats.update(gpu_stats)
+    
+    return system_stats