Update app.py

app.py

@@ -17,16 +17,31 @@ try:
     from langchain_community.vectorstores import FAISS
     from langchain.prompts import PromptTemplate
     from langchain.chains import RetrievalQA
-    from langchain_huggingface import HuggingFaceEndpoint  # Updated import
+    
+    # Updated imports for LLM - try multiple import paths
+    try:
+        from langchain_community.llms import HuggingFaceHub
+        HUGGINGFACE_HUB_AVAILABLE = True
+        logger.info("Using HuggingFaceHub from langchain_community")
+    except ImportError:
+        try:
+            from langchain.llms import HuggingFaceHub
+            HUGGINGFACE_HUB_AVAILABLE = True
+            logger.info("Using HuggingFaceHub from langchain.llms")
+        except ImportError:
+            try:
+                from langchain_huggingface import HuggingFaceEndpoint
+                HUGGINGFACE_HUB_AVAILABLE = False
+                logger.info("Using HuggingFaceEndpoint as fallback")
+            except ImportError:
+                logger.error("No suitable HuggingFace LLM implementation found")
+                HUGGINGFACE_HUB_AVAILABLE = False
+    
     LANGCHAIN_AVAILABLE = True
 except ImportError as e:
-    try:
-        # Fallback to older import structure
-        from langchain_community.llms import HuggingFaceEndpoint
-        LANGCHAIN_AVAILABLE = True
-    except ImportError as e2:
-        logger.error(f"LangChain import error: {e}, {e2}")
-        LANGCHAIN_AVAILABLE = False
+    logger.error(f"LangChain import error: {e}")
+    LANGCHAIN_AVAILABLE = False
+    HUGGINGFACE_HUB_AVAILABLE = False
 
 # Create PDFs folder if it doesn't exist
 PDF_FOLDER_PATH = "./pdfs"
@@ -63,57 +78,127 @@ def initialize_models():
         return False, f"❌ Error initializing models: {str(e)}"
 
 def create_llm():
-    """Create and return the LLM instance with improved error handling"""
+    """Create and return the LLM instance with proper Runnable interface"""
     hf_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
     
+    if not hf_token:
+        logger.error("HuggingFace API token not found")
+        return create_fallback_llm()
+    
     try:
-        # Try different model configurations
-        models_to_try = [
-            "microsoft/DialoGPT-medium",
-            "google/flan-t5-base", 
-            "microsoft/DialoGPT-small",
-            "tiiuae/falcon-7b-instruct"
-        ]
-        
-        for model_id in models_to_try:
-            try:
-                llm = HuggingFaceEndpoint(
-                    repo_id=model_id,
-                    temperature=0.7,
-                    max_new_tokens=512,
-                    huggingfacehub_api_token=hf_token,
-                    model_kwargs={
-                        "max_length": 512,
-                        "do_sample": True,
-                        "temperature": 0.7,
-                        "top_p": 0.9,
-                        "top_k": 50
-                    }
-                )
-                logger.info(f"Successfully initialized LLM with model: {model_id}")
-                return llm
-            except Exception as model_error:
-                logger.warning(f"Failed to initialize {model_id}: {model_error}")
-                continue
+        # Prioritize HuggingFaceHub as it's more stable with LangChain
+        if HUGGINGFACE_HUB_AVAILABLE:
+            models_to_try = [
+                "mistralai/Mistral-7B-Instruct-v0.2",
+                "microsoft/DialoGPT-medium",
+                "google/flan-t5-base",
+                "microsoft/DialoGPT-small",
+                "tiiuae/falcon-7b-instruct"
+            ]
+            
+            for model_id in models_to_try:
+                try:
+                    llm = HuggingFaceHub(
+                        repo_id=model_id,
+                        huggingfacehub_api_token=hf_token,
+                        model_kwargs={
+                            "temperature": 0.7,
+                            "max_new_tokens": 512,
+                            "max_length": 512,
+                            "do_sample": True,
+                            "top_p": 0.9,
+                            "top_k": 50
+                        }
+                    )
+                    logger.info(f"Successfully initialized HuggingFaceHub with model: {model_id}")
+                    return llm
+                except Exception as model_error:
+                    logger.warning(f"Failed to initialize {model_id} with HuggingFaceHub: {model_error}")
+                    continue
         
-        # If all models fail, raise the last error
+        # Fallback to HuggingFaceEndpoint if HuggingFaceHub is not available
+        try:
+            from langchain_huggingface import HuggingFaceEndpoint
+            
+            models_to_try = [
+                "mistralai/Mistral-7B-Instruct-v0.2",
+                "microsoft/DialoGPT-medium",
+                "google/flan-t5-base"
+            ]
+            
+            for model_id in models_to_try:
+                try:
+                    llm = HuggingFaceEndpoint(
+                        repo_id=model_id,
+                        temperature=0.7,
+                        max_new_tokens=512,
+                        huggingfacehub_api_token=hf_token,
+                        model_kwargs={
+                            "max_length": 512,
+                            "do_sample": True,
+                            "temperature": 0.7,
+                            "top_p": 0.9,
+                            "top_k": 50
+                        }
+                    )
+                    logger.info(f"Successfully initialized HuggingFaceEndpoint with model: {model_id}")
+                    return llm
+                except Exception as model_error:
+                    logger.warning(f"Failed to initialize {model_id} with HuggingFaceEndpoint: {model_error}")
+                    continue
+        except ImportError:
+            pass
+        
+        # If all else fails, return fallback
         raise Exception("All model initialization attempts failed")
         
     except Exception as e:
         logger.error(f"LLM creation error: {e}")
-        # Return a simple fallback that doesn't use HuggingFace API
         return create_fallback_llm()
 
 def create_fallback_llm():
-    """Create a simple fallback LLM for basic responses"""
-    class FallbackLLM:
-        def __call__(self, prompt):
-            return "I apologize, but I'm experiencing technical difficulties with the language model. Please try again later or contact support."
+    """Create a proper LangChain-compatible fallback LLM"""
+    try:
+        from langchain.llms.base import LLM
+        from langchain.callbacks.manager import CallbackManagerForLLMRun
+        from typing import Optional, List, Any
         
-        def invoke(self, prompt):
-            return self.__call__(prompt)
-    
-    return FallbackLLM()
+        class FallbackLLM(LLM):
+            """A simple fallback LLM that provides basic responses"""
+            
+            @property
+            def _llm_type(self) -> str:
+                return "fallback"
+            
+            def _call(
+                self,
+                prompt: str,
+                stop: Optional[List[str]] = None,
+                run_manager: Optional[CallbackManagerForLLMRun] = None,
+                **kwargs: Any,
+            ) -> str:
+                """Basic response generation"""
+                if "summarize" in prompt.lower():
+                    return "I apologize, but I'm currently experiencing technical difficulties with the AI model. However, I can see that you're asking about content in your documents. Please try rephrasing your question or check if the model service is available."
+                elif "what" in prompt.lower() or "how" in prompt.lower():
+                    return "I'm having trouble processing your question due to technical issues with the language model. The document search is working, but I cannot generate detailed responses right now. Please try again later."
+                else:
+                    return "I apologize, but I'm experiencing technical difficulties with the language model. The document processing is working correctly, but response generation is currently unavailable. Please try again later or contact support."
+        
+        return FallbackLLM()
+        
+    except ImportError:
+        # If we can't even import the base LLM class, create a simple mock
+        logger.error("Cannot create proper fallback LLM - LangChain base classes not available")
+        
+        class SimpleFallback:
+            def invoke(self, prompt):
+                return "System temporarily unavailable. Please try again later."
+            
+            def __call__(self, prompt):
+                return self.invoke(prompt)
+        
+        return SimpleFallback()
 
 def load_preloaded_pdfs(chunk_size=1000, chunk_overlap=200):
     """Load PDFs from the pre-existing folder"""
@@ -169,7 +254,7 @@ Helpful Answer:
         # Initialize LLM using the updated function
         llm = create_llm()
         
-        # Create RetrievalQA chain with error handling
+        # Create RetrievalQA chain with better error handling
         try:
             retrieval_qa = RetrievalQA.from_chain_type(
                 llm=llm,
@@ -178,6 +263,15 @@ Helpful Answer:
                 return_source_documents=True,
                 chain_type_kwargs={"prompt": prompt}
             )
+            
+            # Test the chain with a simple query to ensure it works
+            try:
+                test_result = retrieval_qa({"query": "test"})
+                logger.info("QA chain test successful")
+            except Exception as test_error:
+                logger.warning(f"QA chain test failed: {test_error}")
+                # Chain created but might have issues - continue anyway
+            
         except Exception as chain_error:
             logger.error(f"Chain creation error: {chain_error}")
             return f"❌ Error creating QA chain: {str(chain_error)}"
@@ -292,7 +386,7 @@ Helpful Answer:
         # Initialize LLM using the updated function
         llm = create_llm()
         
-        # Create RetrievalQA chain with error handling
+        # Create RetrievalQA chain with better error handling
         try:
             retrieval_qa = RetrievalQA.from_chain_type(
                 llm=llm,
@@ -301,6 +395,14 @@ Helpful Answer:
                 return_source_documents=True,
                 chain_type_kwargs={"prompt": prompt}
             )
+            
+            # Test the chain
+            try:
+                test_result = retrieval_qa({"query": "test"})
+                logger.info("QA chain test successful")
+            except Exception as test_error:
+                logger.warning(f"QA chain test failed: {test_error}")
+            
         except Exception as chain_error:
             logger.error(f"Chain creation error: {chain_error}")
             return f"❌ Error creating QA chain: {str(chain_error)}"
@@ -720,22 +822,87 @@ def create_interface():
         gr.Markdown("""
         ---
         <div style="text-align: center; color: #666; font-size: 0.9em;">
-        💡 <strong>Tip:</strong> For best results, ask specific questions about your documents
+        💡 <strong>Tips:</strong> Upload multiple PDFs • Use specific questions • Check sources for accuracy<br>
+        🔧 <strong>Powered by:</strong> LangChain • HuggingFace • FAISS • Gradio
         </div>
         """)
     
     return demo
 
+# Check if environment is properly configured
+def check_environment():
+    """Check if the environment is properly configured"""
+    issues = []
+    
+    if not LANGCHAIN_AVAILABLE:
+        issues.append("❌ LangChain not available - please install: pip install langchain langchain-community")
+    
+    if not os.getenv("HUGGINGFACEHUB_API_TOKEN"):
+        issues.append("❌ HuggingFace API token not found - set HUGGINGFACEHUB_API_TOKEN environment variable")
+    
+    return issues
+
+# Main execution
 if __name__ == "__main__":
-    # Check if running on HuggingFace Spaces
-    if os.getenv("SPACE_ID"):
+    print("🚀 Starting PDF RAG System...")
+    
+    # Check environment
+    env_issues = check_environment()
+    if env_issues:
+        print("\n⚠️  Environment Issues Detected:")
+        for issue in env_issues:
+            print(f"   {issue}")
+        print("\n📋 Setup Instructions:")
+        print("   1. Install dependencies: pip install langchain langchain-community sentence-transformers faiss-cpu PyPDF2 gradio")
+        print("   2. Get HuggingFace token: https://huggingface.co/settings/tokens")
+        print("   3. Set environment variable: export HUGGINGFACEHUB_API_TOKEN=your_token_here")
+        print("   4. Restart the application")
+        print("\n🔄 Continuing with limited functionality...\n")
+    
+    # Initialize models on startup
+    if LANGCHAIN_AVAILABLE:
+        print("🔧 Initializing models...")
+        success, message = initialize_models()
+        print(f"   {message}")
+    
+    # Check for pre-loaded PDFs
+    if PRELOADED_PDFS:
+        pdf_count = len([f for f in os.listdir(PDF_FOLDER_PATH) if f.endswith('.pdf')])
+        print(f"📚 Found {pdf_count} pre-loaded PDF files in ./pdfs/")
+    
+    try:
+        # Create and launch the interface
         demo = create_interface()
+        
+        print("🌐 Launching web interface...")
+        print("   📱 Mobile-optimized interface")
+        print("   🖥️  Desktop and tablet supported")
+        print("   🔗 Access the app in your browser")
+        
+        # Launch with configuration for different environments
         demo.launch(
-            server_name="0.0.0.0",
-            server_port=7860,
-            share=False
+            share=False,  # Set to True if you want a public shareable link
+            server_name="0.0.0.0",  # Allow external access
+            server_port=7860,  # Default Gradio port
+            inbrowser=True,  # Auto-open browser
+            show_error=True,  # Show detailed errors
+            quiet=False  # Show startup logs
         )
-    else:
-        # Local development
-        demo = create_interface()
-        demo.launch(share=True)
+        
+    except Exception as e:
+        print(f"❌ Failed to launch interface: {e}")
+        print("🔧 Try these troubleshooting steps:")
+        print("   1. Check if port 7860 is available")
+        print("   2. Install Gradio: pip install gradio")
+        print("   3. Check firewall settings")
+        print("   4. Try running with: python app.py")
+        
+    except KeyboardInterrupt:
+        print("\n👋 Shutting down PDF RAG System...")
+        print("   Thank you for using the application!")
+        
+    finally:
+        # Cleanup
+        if 'vectorstore' in globals() and vectorstore is not None:
+            print("🧹 Cleaning up resources...")
+        print("✅ Shutdown complete.")