removed punkt

app.py

@@ -1,10 +1,6 @@
 import os
 import logging
 import re
-import nltk
-import spacy
-import traceback
-from nltk.tokenize import sent_tokenize
 from langchain.vectorstores import Chroma
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.runnables import RunnablePassthrough
@@ -20,13 +16,9 @@ import pandas as pd
 import json
 
 # Enable logging for debugging
-logging.basicConfig(level=logging.DEBUG)
+logging.basicConfig(level=logging.INFO)  # Changed to INFO to reduce verbosity
 logger = logging.getLogger(__name__)
 
-# Set NLTK data path to the local 'nltk_data' directory
-nltk.data.path.append(os.path.join(os.path.dirname(__file__), 'nltk_data'))
-logger.debug("Configured NLTK data path to local 'nltk_data' directory.")
-
 # Function to clean the API key
 def clean_api_key(key):
     return ''.join(c for c in key if ord(c) < 128)
@@ -77,83 +69,41 @@ def load_documents(file_paths):
                 logger.warning(f"Unsupported file format: {file_path}")
         except Exception as e:
             logger.error(f"Error processing file {file_path}: {e}")
-            logger.error(traceback.format_exc())
+            logger.debug("Exception details:", exc_info=True)
     return docs
 
-# Function to ensure the response ends with complete sentences using NLTK
+# Function to ensure the response ends with complete sentences
 def ensure_complete_sentences(text):
-    logger.debug("Ensuring complete sentences for the given text.")
-    try:
-        sentences = sent_tokenize(text)
-        if sentences:
-            return ' '.join(sentences).strip()
-        return text  # Return as is if no complete sentence is found
-    except LookupError as e:
-        logger.error("NLTK resource 'punkt' not found. Attempting to download again.")
-        try:
-            nltk.download('punkt', download_dir=os.path.join(os.path.dirname(__file__), 'nltk_data'))
-            nltk.data.path.append(os.path.join(os.path.dirname(__file__), 'nltk_data'))
-            sentences = sent_tokenize(text)
-            return ' '.join(sentences).strip()
-        except Exception as e_inner:
-            logger.error("Failed to download 'punkt' resource.")
-            logger.error(traceback.format_exc())
-            raise e_inner
-    except Exception as e:
-        logger.error("Unexpected error during sentence tokenization.")
-        logger.error(traceback.format_exc())
-        raise e
-
-# Advanced input validation using spaCy (Section 8a)
-def is_valid_input_nlp(text, threshold=0.5):
+    # Use regex to find all complete sentences
+    sentences = re.findall(r'[^.!?]*[.!?]', text)
+    if sentences:
+        # Join all complete sentences to form the complete answer
+        return ' '.join(sentences).strip()
+    return text  # Return as is if no complete sentence is found
+
+# Function to check if input is valid
+def is_valid_input(text):
     """
-    Validates input text using spaCy's NLP capabilities.
-
-    Parameters:
-    - text (str): The input text to validate.
-    - threshold (float): The minimum ratio of meaningful tokens required.
-
-    Returns:
-    - bool: True if the input is valid, False otherwise.
+    Checks if the input text is meaningful.
+    Returns True if the text contains alphabetic characters and is of sufficient length.
     """
     if not text or text.strip() == "":
-        logger.debug("Input text is empty or contains only whitespace.")
         return False
-    doc = nlp(text)
-    meaningful_tokens = [token for token in doc if token.is_alpha]
-    if not meaningful_tokens:
-        logger.debug("No meaningful (alphabetic) tokens found in input.")
+    # Regex to check for at least one alphabetic character
+    if not re.search('[A-Za-z]', text):
         return False
-    ratio = len(meaningful_tokens) / len(doc)
-    logger.debug(f"Meaningful tokens ratio: {ratio}")
-    return ratio >= threshold
-
-# Function to estimate prompt tokens (simple word count approximation)
-def estimate_prompt_tokens(prompt):
-    """
-    Estimates the number of tokens in the prompt.
-    This is a placeholder function. Replace it with actual token estimation logic.
-
-    Parameters:
-    - prompt (str): The prompt text.
-
-    Returns:
-    - int: Estimated number of tokens.
-    """
-    return len(prompt.split())
+    # Additional check: minimum length
+    if len(text.strip()) < 5:
+        return False
+    return True
 
 # Initialize the LLM using ChatGroq with GROQ's API
-def initialize_llm(model, temperature, max_tokens, prompt_template):
+def initialize_llm(model, temperature, max_tokens):
     try:
-        # Estimate prompt tokens
-        estimated_prompt_tokens = estimate_prompt_tokens(prompt_template)
-        logger.debug(f"Estimated prompt tokens: {estimated_prompt_tokens}")
-
-        # Allocate remaining tokens to response
-        response_max_tokens = max_tokens - estimated_prompt_tokens
-        logger.debug(f"Response max tokens: {response_max_tokens}")
-
-        if response_max_tokens <= 100:
+        # Allocate a portion of tokens for the prompt, e.g., 20%
+        prompt_allocation = int(max_tokens * 0.2)
+        response_max_tokens = max_tokens - prompt_allocation
+        if response_max_tokens <= 50:
             raise ValueError("max_tokens is too small to allocate for the response.")
 
         llm = ChatGroq(
@@ -162,53 +112,26 @@ def initialize_llm(model, temperature, max_tokens, prompt_template):
             max_tokens=response_max_tokens,  # Adjusted max_tokens
             api_key=api_key  # Ensure the API key is passed correctly
         )
-        logger.debug("LLM initialized successfully.")
+        logger.info("LLM initialized successfully.")
         return llm
     except Exception as e:
         logger.error(f"Error initializing LLM: {e}")
-        logger.error(traceback.format_exc())
-        raise e
+        raise
 
 # Create the RAG pipeline
 def create_rag_pipeline(file_paths, model, temperature, max_tokens):
     try:
-        # Define the prompt template first to estimate tokens
-        custom_prompt_template = PromptTemplate(
-            input_variables=["context", "question"],
-            template="""
-            You are an AI assistant with expertise in daily wellness. Your aim is to provide detailed and comprehensive solutions regarding daily wellness topics without unnecessary verbosity.
-
-            Context:
-            {context}
-
-            Question:
-            {question}
-
-            Provide a thorough and complete answer, including relevant examples and a suggested schedule. Ensure that the response does not end abruptly.
-            """
-        )
-
-        # Estimate prompt tokens
-        estimated_prompt_tokens = estimate_prompt_tokens(custom_prompt_template.template)
-        logger.debug(f"Estimated prompt tokens from template: {estimated_prompt_tokens}")
-
-        # Initialize the LLM with token allocation
-        llm = initialize_llm(model, temperature, max_tokens, custom_prompt_template.template)
-
-        # Load and process documents
+        llm = initialize_llm(model, temperature, max_tokens)
         docs = load_documents(file_paths)
         if not docs:
             logger.warning("No documents were loaded. Please check your file paths and formats.")
             return None, "No documents were loaded. Please check your file paths and formats."
 
-        # Split documents into chunks
         text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
         splits = text_splitter.split_documents(docs)
-        logger.debug(f"Documents split into {len(splits)} chunks.")
 
         # Initialize the embedding model
         embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        logger.debug("Embedding model initialized successfully.")
 
         # Use a temporary directory for Chroma vectorstore to prevent caching issues on Hugging Face Spaces
         vectorstore = Chroma.from_documents(
@@ -217,25 +140,39 @@ def create_rag_pipeline(file_paths, model, temperature, max_tokens):
             persist_directory="/tmp/chroma_db"  # Temporary storage directory
         )
         vectorstore.persist()  # Save the database to disk
-        logger.debug("Vectorstore initialized and persisted successfully.")
+        logger.info("Vectorstore initialized and persisted successfully.")
 
         retriever = vectorstore.as_retriever()
 
-        # Create the RetrievalQA chain
+        custom_prompt_template = PromptTemplate(
+            input_variables=["context", "question"],
+            template="""
+            You are an AI assistant with expertise in daily wellness. Your aim is to provide detailed and comprehensive solutions regarding daily wellness topics without unnecessary verbosity.
+
+            Context:
+            {context}
+
+            Question:
+            {question}
+
+            Provide a thorough and complete answer, including relevant examples and a suggested schedule. Ensure that the response does not end abruptly.
+            """
+        )
+
         rag_chain = RetrievalQA.from_chain_type(
             llm=llm,
             chain_type="stuff",
             retriever=retriever,
             chain_type_kwargs={"prompt": custom_prompt_template}
         )
-        logger.debug("RAG pipeline created successfully.")
+        logger.info("RAG pipeline created successfully.")
         return rag_chain, "Pipeline created successfully."
     except Exception as e:
         logger.error(f"Error creating RAG pipeline: {e}")
-        logger.error(traceback.format_exc())
+        logger.debug("Exception details:", exc_info=True)
         return None, f"Error creating RAG pipeline: {e}"
 
-# Function to handle feedback (Section 8d)
+# Function to handle feedback (Optional Enhancement)
 def handle_feedback(feedback_text):
     """
     Handles user feedback by logging it.
@@ -254,43 +191,48 @@ def handle_feedback(feedback_text):
     else:
         return "No feedback provided."
 
+# Initialize the RAG pipeline once at startup
+# Define the file paths (ensure 'AIChatbot.csv' is in the root directory of your Space)
+file_paths = ['AIChatbot.csv']
+model = "llama3-8b-8192"  # Default model name
+temperature = 0.7  # Default temperature
+max_tokens = 500  # Default max tokens
+
+rag_chain, message = create_rag_pipeline(file_paths, model, temperature, max_tokens)
+if rag_chain is None:
+    logger.error("Failed to initialize RAG pipeline at startup.")
+    # Depending on your preference, you might want to exit or continue. Here, we'll continue.
+
 # Function to answer questions with input validation and post-processing
-def answer_question(file_paths, model, temperature, max_tokens, question, feedback):
+def answer_question(model, temperature, max_tokens, question, feedback):
+    # Validate input
+    if not is_valid_input(question):
+        logger.info("Received invalid input from user.")
+        return "Please provide a valid question or input containing meaningful text.", ""
+
+    # Check if the RAG pipeline needs to be re-initialized (e.g., if model or parameters have changed)
+    # For simplicity, we'll assume the pipeline remains the same. For dynamic models, implement re-initialization here.
+
     try:
-        # Validate input using spaCy-based validation
-        if not is_valid_input_nlp(question):
-            logger.debug("Invalid input detected.")
-            return "Please provide a valid question or input containing meaningful text.", ""
+        answer = rag_chain.run(question)
+        logger.info("Question answered successfully.")
+        # Post-process to ensure the answer ends with complete sentences
+        complete_answer = ensure_complete_sentences(answer)
 
-        rag_chain, message = create_rag_pipeline(file_paths, model, temperature, max_tokens)
-        if rag_chain is None:
-            logger.debug("RAG pipeline creation failed.")
-            return message, ""
+        # Handle feedback
+        feedback_response = handle_feedback(feedback)
 
-        try:
-            answer = rag_chain.run(question)
-            logger.debug("Question answered successfully.")
-            # Post-process to ensure the answer ends with complete sentences
-            complete_answer = ensure_complete_sentences(answer)
-
-            # Handle feedback
-            feedback_response = handle_feedback(feedback)
-
-            return complete_answer, feedback_response
-        except Exception as e_inner:
-            logger.error(f"Error during RAG pipeline execution: {e_inner}")
-            logger.error(traceback.format_exc())
-            return f"Error during RAG pipeline execution: {e_inner}", ""
-
-    except Exception as e_outer:
-        logger.error(f"Unexpected error in answer_question: {e_outer}")
-        logger.error(traceback.format_exc())
-        return f"Unexpected error: {e_outer}", ""
-
-# Gradio Interface with Feedback Mechanism (Section 8d)
+        return complete_answer, feedback_response
+    except Exception as e_inner:
+        logger.error(f"Error during RAG pipeline execution: {e_inner}")
+        logger.debug("Exception details:", exc_info=True)
+        return f"Error during RAG pipeline execution: {e_inner}", ""
+
+# Gradio Interface with Feedback Mechanism
 def gradio_interface(model, temperature, max_tokens, question, feedback):
-    file_paths = ['AIChatbot.csv']  # Ensure this file is present in your Space root directory
-    return answer_question(file_paths, model, temperature, max_tokens, question, feedback)
+    # Optionally, you can add functionality to update the RAG pipeline if model or parameters change
+    # For now, we'll ignore changes to model parameters after initialization
+    return answer_question(model, temperature, max_tokens, question, feedback)
 
 # Define Gradio UI
 interface = gr.Interface(
@@ -298,7 +240,7 @@ interface = gr.Interface(
     inputs=[
         gr.Textbox(
             label="Model Name",
-            value="llama3-8b-8192",
+            value=model,
             placeholder="e.g., llama3-8b-8192"
         ),
         gr.Slider(
@@ -306,7 +248,7 @@ interface = gr.Interface(
             minimum=0,
             maximum=1,
             step=0.01,
-            value=0.7,
+            value=temperature,
             info="Controls the randomness of the response. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."
         ),
         gr.Slider(
@@ -314,7 +256,7 @@ interface = gr.Interface(
             minimum=200,
             maximum=2048,
             step=1,
-            value=500,
+            value=max_tokens,
             info="Determines the maximum number of tokens in the response. Higher values allow for longer answers."
         ),
         gr.Textbox(