Update app.py

app.py

@@ -1,87 +1,128 @@
-import os
 import gradio as gr
-import faiss
-import numpy as np
 import torch
-from langchain_community.vectorstores import FAISS  # Updated import for FAISS
-from langchain_community.embeddings import SentenceTransformerEmbeddings
-from langchain_community.llms import OpenAI  # Use Groq API or your LLM here
-import PyPDF2
-from gtts import gTTS
 import whisper
-from groq import GroqClient  # Corrected import for Groq SDK
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain.agents import initialize_agent, Tool, AgentType
+from langchain.prompts import PromptTemplate
+from langchain.memory import ConversationBufferMemory
+from gtts import gTTS
+import os
+import PyPDF2
+from groq import Groq
+from sentence_transformers import SentenceTransformer
+import numpy as np
 
-# Initialize FAISS vector store and embeddings
-embedding_model = SentenceTransformerEmbeddings("all-MiniLM-L6-v2")
+# Load Whisper model for transcription
+model = whisper.load_model("base")
 
-# Function to process PDF and create embeddings
-def process_pdf(pdf_file):
-    with open(pdf_file, 'rb') as f:
-        reader = PyPDF2.PdfReader(f)
-        text = ""
-        for page in reader.pages:
-            text += page.extract_text()
-    
-    # Create embeddings for the extracted text from PDF
-    embeddings = embedding_model.embed(text.split("\n"))
-    
-    # Create FAISS index for embeddings
-    index = faiss.IndexFlatL2(embedding_model.embedding_dim)
-    index.add(np.array(embeddings).astype(np.float32))  # Convert embeddings to float32 format for FAISS
-    
-    return index, text
+# Initialize Groq client
+client = Groq(api_key="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")
 
-# Set up Groq API for LLM interaction using GroqClient
-def generate_answer_from_llm(query, model="groq"):
-    client = GroqClient(api_key="your_api_key")  # Initialize the Groq client with your API key
-    response = client.query(model=model, text=query)  # Call the Groq API to get the answer
-    return response['answer']
+# Initialize SentenceTransformer for PDF embedding
+sentence_model = SentenceTransformer('all-MiniLM-L6-v2')
 
-# Main processing function for user input
-def process_input(query, pdf_file=None):
-    # If PDF is provided, process it to create embeddings
-    if pdf_file is not None:
-        index, pdf_text = process_pdf(pdf_file)
-        # Retrieve answer based on closest match from the PDF embeddings
-        faiss_results = index.search(np.array([embedding_model.embed(query)]).astype(np.float32), k=1)
-        answer = pdf_text[faiss_results[1][0]]  # Adjust to retrieve the closest text chunk
-    else:
-        # If no PDF, generate a general answer using LLM via Groq API
-        answer = generate_answer_from_llm(query)
+# Function to transcribe audio
+def transcribe_audio(audio):
+    result = model.transcribe(audio)
+    return result["text"]
 
-    # Convert answer to speech
-    tts = gTTS(answer)
-    audio_fp = "/tmp/response.mp3"
-    tts.save(audio_fp)
+# Function for text-to-speech conversion
+def text_to_speech(text):
+    tts = gTTS(text)
+    audio_path = "/tmp/response.mp3"
+    tts.save(audio_path)
+    return audio_path
 
-    return answer, audio_fp
+# Function to interact with Groq API for LLM responses
+def get_groq_response(question):
+    # Use Groq API to get the answer from LLM
+    chat_completion = client.chat.completions.create(
+        messages=[{"role": "user", "content": question}],
+        model="llama-3.3-70b-versatile",
+    )
+    return chat_completion.choices[0].message.content
 
-# Speech-to-Text (Whisper) function
-def speech_to_text(audio_file):
-    model = whisper.load_model("base")  # Load the OpenAI Whisper model (open-source)
-    result = model.transcribe(audio_file)
-    return result["text"]
+# PDF Processing (chunking, embedding, FAISS)
+def process_pdf(file):
+    # Extract text from PDF
+    pdf_reader = PyPDF2.PdfReader(file)
+    text = ""
+    for page in range(len(pdf_reader.pages)):
+        text += pdf_reader.pages[page].extract_text()
+    
+    # Chunk text into smaller pieces
+    chunk_size = 500  # Can adjust based on requirement
+    chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
+    
+    # Generate embeddings using SentenceTransformer
+    embeddings = sentence_model.encode(chunks)
+    
+    # Store embeddings in FAISS index
+    faiss_index = FAISS.from_embeddings(embeddings)
+    
+    return faiss_index, chunks
 
-# Gradio interface
-def create_ui():
-    with gr.Blocks() as demo:
-        gr.Markdown("### Welcome to the AI-Powered Chatbot with RAG and Voice Input")
+# Function to handle query against PDF embedding
+def get_pdf_response(query, faiss_index):
+    # Retrieve relevant chunk based on query
+    results = faiss_index.similarity_search(query, k=1)  # Adjust k based on requirement
+    
+    # Get the best match and return
+    return results[0].document
+
+# Initialize Gradio components
+with gr.Blocks(css="#output_text { font-size: 18px; margin: 10px 0; }"
+                   "#output_audio { margin-top: 15px; }"
+                   "gradio .gradio-container { background-color: #f8f9fa; border-radius: 15px; padding: 20px; box-shadow: 0 4px 8px rgba(0,0,0,0.1); }"
+                   "gradio .gradio-interface { font-family: 'Arial', sans-serif; }") as demo:
+    gr.Markdown(""" 
+        # Quranic Therapy: Gen-AI Driven Mental Health & Wellness
+        ## Where Faith Meets Technology
+        Interact with the model using your voice or text input and get answers from documents!
+    """, elem_id="header")
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("### Record or Upload Audio")
+            audio_input = gr.Audio(type="filepath", label="Record or Upload Audio", elem_id="audio_input")
         
-        with gr.Row():
-            pdf_upload = gr.File(label="Upload PDF File", type="file")
-            query_input = gr.Textbox(label="Ask your question", placeholder="Type your query here")
-            output_text = gr.Textbox(label="Answer", interactive=False)
-            output_audio = gr.Audio(label="Response Audio", interactive=False)
+        with gr.Column(scale=3):
+            gr.Markdown("### Ask Your Question")
+            text_input = gr.Textbox(label="Enter your question", placeholder="Ask a question based on the document...", elem_id="text_input")
         
-        def on_query_submit(query, pdf_file):
-            answer, audio_fp = process_input(query, pdf_file)
-            output_text.update(value=answer)
-            output_audio.update(value=audio_fp)
+        with gr.Column(scale=3):
+            gr.Markdown("### Upload PDF Document")
+            pdf_input = gr.File(label="Upload PDF", type="file", elem_id="pdf_input")
 
-        query_input.submit(on_query_submit, inputs=[query_input, pdf_upload], outputs=[output_text, output_audio])
+    with gr.Row():
+        with gr.Column(scale=5):
+            output_text = gr.Textbox(label="Answer", elem_id="output_text", interactive=False)
+            output_audio = gr.Audio(label="Voice Response", type="filepath", elem_id="output_audio")
 
-    demo.launch()
+    # Button to process the input and generate output
+    def process_input(audio_input, text_input, pdf_input):
+        if audio_input:
+            question = transcribe_audio(audio_input)
+        else:
+            question = text_input
+        
+        # If PDF uploaded, use FAISS for RAG
+        if pdf_input:
+            faiss_index, _ = process_pdf(pdf_input)
+            answer = get_pdf_response(question, faiss_index)
+        else:
+            # Use Groq LLM for general response
+            answer = get_groq_response(question)
+        
+        # Convert the answer to speech and return both text and audio
+        audio_path = text_to_speech(answer)
+        return answer, audio_path
+    
+    # Bind the function to the interface
+    audio_input.change(process_input, inputs=[audio_input, text_input, pdf_input], outputs=[output_text, output_audio])
+    text_input.submit(process_input, inputs=[audio_input, text_input, pdf_input], outputs=[output_text, output_audio])
+    pdf_input.change(process_input, inputs=[audio_input, text_input, pdf_input], outputs=[output_text, output_audio])
 
-# Run the Gradio app
-if __name__ == "__main__":
-    create_ui()
+demo.launch(debug=True)