Update app.py

app.py

@@ -16,13 +16,29 @@ import time
 import groq
 import uuid  # For generating unique filenames
 
-# 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
+# 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")
 
 # Importing chardet (make sure to add chardet to your requirements.txt)
 import chardet
@@ -41,7 +57,22 @@ import uvicorn
 from typing import Optional
 import io
 import soundfile as sf
-import librosa
+
+# 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.")
 
 # Enhanced Whisper model for speech-to-text with better configuration
 try:
@@ -53,24 +84,44 @@ 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}")
-    # Fallback to basic model
-    transcriber = pipeline("automatic-speech-recognition", model="openai/whisper-base.en")
+    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
 
 # Set API Key (Ensure it's stored securely in an environment variable)
 groq.api_key = os.getenv("GROQ_API_KEY")
 
-# Initialize Chat Model
-chat_model = ChatGroq(model_name="llama-3.3-70b-versatile", api_key=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 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"
-)
+# 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
 
 # Short-term memory for the LLM
 chat_memory = []
@@ -140,6 +191,9 @@ 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)
@@ -147,6 +201,9 @@ 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]
 
@@ -173,6 +230,12 @@ 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)
         
@@ -284,6 +347,10 @@ 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)
@@ -312,16 +379,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 sample_rate != AUDIO_SAMPLE_RATE:
+        if LIBROSA_AVAILABLE and 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)
-        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)
+        # 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)
         
         return audio_data, sample_rate
     
@@ -338,6 +405,9 @@ 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
@@ -427,6 +497,12 @@ 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)])
@@ -490,7 +566,13 @@ 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()}
+    return {
+        "status": "healthy", 
+        "timestamp": time.time(),
+        "chat_model_available": CHAT_MODEL_AVAILABLE,
+        "vectorstore_available": VECTORSTORE_AVAILABLE,
+        "stt_available": transcriber is not None
+    }
 
 # Clear chat history function
 def clear_chat_history():
@@ -598,15 +680,21 @@ def tutor_ai_chatbot():
                     gr.Video("We_not_me_video.mp4", label="Introduction Video")
 
         # Launch the application
-        gradio_app.launch(share=False)
+        gradio_app.launch(share=False, server_name="0.0.0.0", server_port=7860)
 
-# Run both FastAPI and Gradio
+# Run the application based on command line arguments
 if __name__ == "__main__":
-    import threading
-    
-    # Start Gradio in a separate thread
-    gradio_thread = threading.Thread(target=tutor_ai_chatbot, daemon=True)
-    gradio_thread.start()
+    import sys
     
-    # Start FastAPI
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    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()