revised app.py and revise requirements.txt(handled for 123 box)

app.py

@@ -1,5 +1,9 @@
 import os
 import logging
+import re
+import nltk
+import spacy
+from nltk.tokenize import sent_tokenize
 from langchain.vectorstores import Chroma
 from langchain_core.output_parsers import StrOutputParser
 from langchain_core.runnables import RunnablePassthrough
@@ -13,7 +17,18 @@ import chardet
 import gradio as gr
 import pandas as pd
 import json
-import re
+
+# Download required nltk resources
+nltk.download('punkt')
+
+# Load spaCy English model
+try:
+    nlp = spacy.load("en_core_web_sm")
+except OSError:
+    # If the model is not found, download it
+    from spacy.cli import download
+    download("en_core_web_sm")
+    nlp = spacy.load("en_core_web_sm")
 
 # Enable logging for debugging
 logging.basicConfig(level=logging.DEBUG)
@@ -71,33 +86,58 @@ def load_documents(file_paths):
             logger.error(f"Error processing file {file_path}: {e}")
     return docs
 
-# Function to ensure the response ends with complete sentences
+# Function to ensure the response ends with complete sentences using nltk
 def ensure_complete_sentences(text):
-    # Use regex to find all complete sentences
-    sentences = re.findall(r'[^.!?]*[.!?]', text)
+    sentences = sent_tokenize(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):
+# Advanced input validation using spaCy (Section 8a)
+def is_valid_input_nlp(text, threshold=0.5):
     """
-    Checks if the input text is meaningful.
-    Returns True if the text contains alphabetic characters.
+    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.
     """
     if not text or text.strip() == "":
         return False
-    # Regex to check for at least one alphabetic character
-    return bool(re.search('[A-Za-z]', text))
+    doc = nlp(text)
+    meaningful_tokens = [token for token in doc if token.is_alpha]
+    if not meaningful_tokens:
+        return False
+    ratio = len(meaningful_tokens) / len(doc)
+    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())
 
 # Initialize the LLM using ChatGroq with GROQ's API
-def initialize_llm(model, temperature, max_tokens):
+def initialize_llm(model, temperature, max_tokens, prompt_template):
     try:
-        # 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:
+        # Estimate prompt tokens
+        estimated_prompt_tokens = estimate_prompt_tokens(prompt_template)
+
+        # Allocate remaining tokens to response
+        response_max_tokens = max_tokens - estimated_prompt_tokens
+
+        if response_max_tokens <= 100:
             raise ValueError("max_tokens is too small to allocate for the response.")
 
         llm = ChatGroq(
@@ -115,12 +155,35 @@ def initialize_llm(model, temperature, max_tokens):
 # Create the RAG pipeline
 def create_rag_pipeline(file_paths, model, temperature, max_tokens):
     try:
-        llm = initialize_llm(model, temperature, max_tokens)
+        # 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)
+
+        # Initialize the LLM with token allocation
+        llm = initialize_llm(model, temperature, max_tokens, custom_prompt_template.template)
+
+        # Load and process documents
         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)
 
@@ -138,21 +201,7 @@ def create_rag_pipeline(file_paths, model, temperature, max_tokens):
 
         retriever = vectorstore.as_retriever()
 
-        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.
-            """
-        )
-
+        # Create the RetrievalQA chain
         rag_chain = RetrievalQA.from_chain_type(
             llm=llm,
             chain_type="stuff",
@@ -165,41 +214,100 @@ def create_rag_pipeline(file_paths, model, temperature, max_tokens):
         logger.error(f"Error creating RAG pipeline: {e}")
         return None, f"Error creating RAG pipeline: {e}"
 
+# Function to handle feedback (Section 8d)
+def handle_feedback(feedback_text):
+    """
+    Handles user feedback by logging it.
+    In a production environment, consider storing feedback in a database or external service.
+
+    Parameters:
+    - feedback_text (str): The feedback provided by the user.
+
+    Returns:
+    - str: Acknowledgment message.
+    """
+    if feedback_text and feedback_text.strip() != "":
+        # For demonstration, we'll log the feedback. Replace this with database storage if needed.
+        logger.info(f"User Feedback: {feedback_text}")
+        return "Thank you for your feedback!"
+    else:
+        return "No feedback provided."
+
 # Function to answer questions with input validation and post-processing
-def answer_question(file_paths, model, temperature, max_tokens, question):
-    if not is_valid_input(question):
-        return "Please provide a valid question or input containing meaningful text."
+def answer_question(file_paths, model, temperature, max_tokens, question, feedback):
+    # Validate input using spaCy-based validation
+    if not is_valid_input_nlp(question):
+        return "Please provide a valid question or input containing meaningful text.", ""
 
     rag_chain, message = create_rag_pipeline(file_paths, model, temperature, max_tokens)
     if rag_chain is None:
-        return message
+        return message, ""
+
     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)
-        return complete_answer
+
+        # Handle feedback
+        feedback_response = handle_feedback(feedback)
+
+        return complete_answer, feedback_response
     except Exception as e:
         logger.error(f"Error during RAG pipeline execution: {e}")
-        return f"Error during RAG pipeline execution: {e}"
+        return f"Error during RAG pipeline execution: {e}", ""
 
-# Gradio Interface
-def gradio_interface(model, temperature, max_tokens, question):
+# Gradio Interface with Feedback Mechanism (Section 8d)
+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)
+    return answer_question(file_paths, model, temperature, max_tokens, question, feedback)
 
 # Define Gradio UI
 interface = gr.Interface(
     fn=gradio_interface,
     inputs=[
-        gr.Textbox(label="Model Name", value="llama3-8b-8192"),
-        gr.Slider(label="Temperature", minimum=0, maximum=1, step=0.01, value=0.7),
-        gr.Slider(label="Max Tokens", minimum=200, maximum=1024, step=1, value=500),
-        gr.Textbox(label="Question")
+        gr.Textbox(
+            label="Model Name",
+            value="llama3-8b-8192",
+            placeholder="e.g., llama3-8b-8192"
+        ),
+        gr.Slider(
+            label="Temperature",
+            minimum=0,
+            maximum=1,
+            step=0.01,
+            value=0.7,
+            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(
+            label="Max Tokens",
+            minimum=200,
+            maximum=2048,
+            step=1,
+            value=500,
+            info="Determines the maximum number of tokens in the response. Higher values allow for longer answers."
+        ),
+        gr.Textbox(
+            label="Question",
+            placeholder="e.g., What is box breathing and how does it help reduce anxiety?"
+        ),
+        gr.Textbox(
+            label="Feedback",
+            placeholder="Provide your feedback here...",
+            lines=2
+        )
+    ],
+    outputs=[
+        "text",
+        "text"
     ],
-    outputs="text",
     title="Daily Wellness AI",
-    description="Ask questions about daily wellness and get detailed solutions."
+    description="Ask questions about daily wellness and get detailed solutions.",
+    examples=[
+        ["llama3-8b-8192", 0.7, 500, "What is box breathing and how does it help reduce anxiety?", "Great explanation!"],
+        ["llama3-8b-8192", 0.6, 600, "Provide a daily wellness schedule incorporating box breathing techniques.", "Very helpful, thank you!"]
+    ],
+    allow_flagging="never"  # Disable default flagging; using custom feedback
 )
 
 # Launch Gradio app without share=True (not supported on Hugging Face Spaces)

requirements.txt

@@ -1,13 +1,14 @@
+accelerate>=0.20.3
+chardet>=5.1.0
+chromadb>=0.4.6
+gradio>=3.32.0
 langchain>=0.0.200
-langchain-community
-langchain_huggingface
-langchain_groq
-chromadb
-chardet
-gradio
-pandas
-sentence-transformers
-transformers
-accelerate
-torch
-
+langchain-community>=0.0.4
+langchain_groq>=0.0.1
+langchain_huggingface>=0.0.1
+nltk>=3.8.1
+pandas>=2.0.3
+sentence-transformers>=2.2.2
+spacy>=3.5.3
+torch>=2.0.0
+transformers>=4.30.0