Update app.py

app.py

@@ -16,29 +16,13 @@ import time
 import groq
 import uuid  # For generating unique filenames
 
-# Updated imports for LangChain compatibility
-try:
-    # For newer versions of LangChain
-    from langchain_groq import ChatGroq
-    from langchain_core.messages import HumanMessage
-    from langchain.text_splitter import RecursiveCharacterTextSplitter
-    from langchain_community.vectorstores import Chroma
-    from langchain_community.embeddings import HuggingFaceEmbeddings
-    from langchain_core.documents import Document
-except ImportError:
-    # Fallback for older versions
-    try:
-        from langchain_groq import ChatGroq
-        from langchain.schema import HumanMessage
-        from langchain.text_splitter import RecursiveCharacterTextSplitter
-        from langchain_community.vectorstores import Chroma
-        from langchain_community.embeddings import HuggingFaceEmbeddings
-        from langchain.docstore.document import Document
-    except ImportError as e:
-        print(f"Import error: {e}")
-        # Minimal imports to keep the app running
-        import warnings
-        warnings.warn("Some LangChain components not available")
+# Updated imports to address LangChain deprecation warnings:
+from langchain_groq import ChatGroq
+from langchain.schema import HumanMessage
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain.docstore.document import Document
 
 # Importing chardet (make sure to add chardet to your requirements.txt)
 import chardet
@@ -57,22 +41,7 @@ import uvicorn
 from typing import Optional
 import io
 import soundfile as sf
-
-# Try to import librosa for audio processing, but make it optional
-try:
-    import librosa
-    LIBROSA_AVAILABLE = True
-except ImportError:
-    LIBROSA_AVAILABLE = False
-    print("Warning: librosa not available. Audio preprocessing will be limited.")
-
-# Try to import scipy for audio filtering, but make it optional
-try:
-    import scipy.signal as sp
-    SCIPY_AVAILABLE = True
-except ImportError:
-    SCIPY_AVAILABLE = False
-    print("Warning: scipy not available. Audio filtering will be limited.")
+import librosa
 
 # Enhanced Whisper model for speech-to-text with better configuration
 try:
@@ -84,44 +53,24 @@ try:
         stride_length_s=5,
         batch_size=8
     )
-    print("Loaded Whisper-small model successfully")
 except Exception as e:
     print(f"Warning: Could not load enhanced Whisper model: {e}")
-    try:
-        # Fallback to basic model
-        transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
-        print("Loaded Whisper-base model as fallback")
-    except Exception as e2:
-        print(f"Error loading any Whisper model: {e2}")
-        transcriber = None
+    # Fallback to basic model
+    transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
 
 # Set API Key (Ensure it's stored securely in an environment variable)
 groq.api_key = os.getenv("GROQ_API_KEY")
 
-# Initialize Chat Model with error handling
-try:
-    if groq.api_key:
-        chat_model = ChatGroq(model_name="llama-3.3-70b-versatile", api_key=groq.api_key)
-        CHAT_MODEL_AVAILABLE = True
-    else:
-        print("GROQ_API_KEY not found in environment variables")
-        CHAT_MODEL_AVAILABLE = False
-except Exception as e:
-    print(f"Error initializing chat model: {e}")
-    CHAT_MODEL_AVAILABLE = False
+# Initialize Chat Model
+chat_model = ChatGroq(model_name="llama-3.3-70b-versatile", api_key=groq.api_key)
 
-# Initialize Embeddings and chromaDB with error handling
-try:
-    os.makedirs("chroma_db", exist_ok=True)
-    embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    vectorstore = Chroma(
-        embedding_function=embedding_model,
-        persist_directory="chroma_db"
-    )
-    VECTORSTORE_AVAILABLE = True
-except Exception as e:
-    print(f"Error initializing vectorstore: {e}")
-    VECTORSTORE_AVAILABLE = False
+# Initialize Embeddings and chromaDB
+os.makedirs("chroma_db", exist_ok=True)
+embedding_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+vectorstore = Chroma(
+    embedding_function=embedding_model,
+    persist_directory="chroma_db"
+)
 
 # Short-term memory for the LLM
 chat_memory = []
@@ -191,9 +140,6 @@ def clean_response(response):
 
 # Function to generate quiz based on content
 def generate_quiz(content):
-    if not CHAT_MODEL_AVAILABLE:
-        return "Chat model not available. Please check GROQ_API_KEY configuration."
-    
     prompt = f"{quiz_prompt}\n\nDocument content:\n{content}"
     response = chat_model([HumanMessage(content=prompt)])
     cleaned_response = clean_response(response.content)
@@ -201,9 +147,6 @@ def generate_quiz(content):
 
 # Function to retrieve relevant documents from vectorstore based on user query
 def retrieve_documents(query):
-    if not VECTORSTORE_AVAILABLE:
-        return ["Vector store not available."]
-    
     results = vectorstore.similarity_search(query, k=3)
     return [doc.page_content for doc in results]
 
@@ -230,12 +173,6 @@ def convert_to_tuple_format(chat_history):
 # Function to handle chatbot interactions with short-term memory
 def chat_with_groq(user_input, chat_history):
     try:
-        if not CHAT_MODEL_AVAILABLE:
-            error_msg = "Chat model not available. Please check configuration."
-            chat_history.append({"role": "user", "content": user_input})
-            chat_history.append({"role": "assistant", "content": error_msg})
-            return chat_history, "", None
-
         # Convert message format to tuple format for processing
         tuple_history = convert_to_tuple_format(chat_history)
         
@@ -347,10 +284,6 @@ def process_document(file):
             encoding = detect_encoding(file.name)
             with open(file.name, "r", encoding=encoding, errors="replace") as f:
                 content = f.read()
-        
-        if not VECTORSTORE_AVAILABLE:
-            return f"Document processed but vector store not available. Content preview: {content[:500]}..."
-        
         text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
         documents = [Document(page_content=chunk) for chunk in text_splitter.split_text(content)]
         vectorstore.add_documents(documents)
@@ -379,16 +312,16 @@ def preprocess_audio(audio_data, sample_rate):
             audio_data = audio_data / max_val
         
         # Resample to 16kHz if needed (Whisper works best with 16kHz)
-        if LIBROSA_AVAILABLE and sample_rate != AUDIO_SAMPLE_RATE:
+        if sample_rate != AUDIO_SAMPLE_RATE:
             audio_data = librosa.resample(audio_data, orig_sr=sample_rate, target_sr=AUDIO_SAMPLE_RATE)
             sample_rate = AUDIO_SAMPLE_RATE
         
-        # Apply noise reduction (simple high-pass filter) if scipy is available
-        if SCIPY_AVAILABLE:
-            nyquist = sample_rate / 2
-            cutoff = 80  # High-pass filter cutoff frequency in Hz
-            b, a = sp.butter(2, cutoff/nyquist, btype='high')
-            audio_data = sp.filtfilt(b, a, audio_data)
+        # Apply noise reduction (simple high-pass filter)
+        import scipy.signal as sp
+        nyquist = sample_rate / 2
+        cutoff = 80  # High-pass filter cutoff frequency in Hz
+        b, a = sp.butter(2, cutoff/nyquist, btype='high')
+        audio_data = sp.filtfilt(b, a, audio_data)
         
         return audio_data, sample_rate
     
@@ -405,9 +338,6 @@ def transcribe_audio(audio):
         if audio is None:
             return "No audio input detected."
         
-        if transcriber is None:
-            return "Speech-to-text service not available. Please check model configuration."
-        
         sample_rate, audio_data = audio
         
         # Preprocess audio
@@ -497,12 +427,6 @@ async def api_chat(message: str = Form(...)):
     API endpoint for chat interactions
     """
     try:
-        if not CHAT_MODEL_AVAILABLE:
-            return JSONResponse({
-                "success": False,
-                "error": "Chat model not available"
-            }, status_code=503)
-            
         # Simple chat response without memory for API
         prompt = f"You are a helpful AI tutor. Answer the following question accurately and concisely: {message}"
         response = chat_model([HumanMessage(content=prompt)])
@@ -566,13 +490,7 @@ async def api_process_document(file: UploadFile = File(...)):
 @app.get("/api/health")
 async def health_check():
     """Health check endpoint"""
-    return {
-        "status": "healthy", 
-        "timestamp": time.time(),
-        "chat_model_available": CHAT_MODEL_AVAILABLE,
-        "vectorstore_available": VECTORSTORE_AVAILABLE,
-        "stt_available": transcriber is not None
-    }
+    return {"status": "healthy", "timestamp": time.time()}
 
 # Clear chat history function
 def clear_chat_history():
@@ -680,21 +598,15 @@ def tutor_ai_chatbot():
                     gr.Video("We_not_me_video.mp4", label="Introduction Video")
 
         # Launch the application
-        gradio_app.launch(share=False, server_name="0.0.0.0", server_port=7860)
+        gradio_app.launch(share=False)
 
-# Run the application based on command line arguments
+# Run both FastAPI and Gradio
 if __name__ == "__main__":
-    import sys
+    import threading
+    
+    # Start Gradio in a separate thread
+    gradio_thread = threading.Thread(target=tutor_ai_chatbot, daemon=True)
+    gradio_thread.start()
     
-    if len(sys.argv) > 1 and sys.argv[1] == "api":
-        # Run only FastAPI
-        print("Starting FastAPI server on port 8000...")
-        uvicorn.run(app, host="0.0.0.0", port=8000)
-    elif len(sys.argv) > 1 and sys.argv[1] == "gradio":
-        # Run only Gradio
-        print("Starting Gradio interface on port 7860...")
-        tutor_ai_chatbot()
-    else:
-        # Run both (Gradio in main thread for stability)
-        print("Starting Gradio interface (main thread) and FastAPI server (background)...")
-        tutor_ai_chatbot()
+    # Start FastAPI
+    uvicorn.run(app, host="0.0.0.0", port=8000)