fix

.gitignore

@@ -1 +1,2 @@
-__pycache__
+__pycache__
+model_cache/

services/model_handler.py

@@ -185,6 +185,64 @@ class LocalHuggingFaceModel(Model):
                 error_message = str(e)
             return f"Error during generation: {error_message}"
 
+class DummyModel(Model):
+    def __init__(self):
+        super().__init__(id="dummy-model")
+        
+    async def ainvoke(self, prompt: str, **kwargs) -> str:
+        """Async invoke method"""
+        return await self.invoke(prompt=prompt, **kwargs)
+    
+    async def ainvoke_stream(self, prompt: str, **kwargs):
+        """Async streaming invoke method"""
+        result = await self.invoke(prompt=prompt, **kwargs)
+        yield result
+    
+    def invoke(self, prompt: str, **kwargs) -> str:
+        """Synchronous invoke method"""
+        return Response("Sorry, the model is not available. Please try again later.")
+    
+    def invoke_stream(self, prompt: str, **kwargs):
+        """Synchronous streaming invoke method"""
+        result = self.invoke(prompt=prompt, **kwargs)
+        yield result
+    
+    def parse_provider_response(self, response: str) -> str:
+        """Parse the provider response"""
+        return response
+    
+    def parse_provider_response_delta(self, delta: str) -> str:
+        """Parse the provider response delta for streaming"""
+        return delta
+        
+    async def aresponse(self, prompt=None, **kwargs):
+        """Async response method - required abstract method"""
+        if prompt is None:
+            prompt = kwargs.get('input', '')
+        content = await self.ainvoke(prompt=prompt, **kwargs)
+        return Response(content)
+    
+    async def aresponse_stream(self, prompt=None, **kwargs):
+        """Async streaming response method - required abstract method"""
+        if prompt is None:
+            prompt = kwargs.get('input', '')
+        async for chunk in self.ainvoke_stream(prompt=prompt, **kwargs):
+            yield Response(chunk)
+    
+    def response(self, prompt=None, **kwargs):
+        """Synchronous response method - required abstract method"""
+        if prompt is None:
+            prompt = kwargs.get('input', '')
+        content = self.invoke(prompt=prompt, **kwargs)
+        return Response(content)
+    
+    def response_stream(self, prompt=None, **kwargs):
+        """Synchronous streaming response method - required abstract method"""
+        if prompt is None:
+            prompt = kwargs.get('input', '')
+        for chunk in self.invoke_stream(prompt=prompt, **kwargs):
+            yield Response(chunk)
+
 class ModelHandler:
     def __init__(self):
         """Initialize the model handler"""
@@ -306,22 +364,65 @@ Output:"""
     @staticmethod
     @st.cache_resource
     def _load_model():
+        """Load the model and tokenizer with retry logic"""
+        # Define retry decorator for model loading
+        @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
+        def load_with_retry(model_path):
+            try:
+                logging.info(f"Attempting to load model from {model_path}")
+                tokenizer = AutoTokenizer.from_pretrained(model_path, cache_dir="./model_cache")
+                model = AutoModelForSeq2SeqLM.from_pretrained(
+                    model_path, 
+                    device_map="cpu", 
+                    low_cpu_mem_usage=True,
+                    cache_dir="./model_cache"
+                )
+                logging.info(f"Successfully loaded model from {model_path}")
+                return model, tokenizer
+            except Exception as e:
+                logging.error(f"Error loading model from {model_path}: {str(e)}")
+                raise e
+        
+        # Try primary model first
         try:
-            tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
-            model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_PATH, device_map="cpu", low_cpu_mem_usage=True) 
-            return model, tokenizer
-        except Exception as e:
-            st.error(f"Error loading model: {str(e)}")
-            logging.error(f"Error loading model: {str(e)}")
-            return None, None
+            return load_with_retry(MODEL_PATH)
+        except Exception as primary_error:
+            logging.error(f"Failed to load primary model ({MODEL_PATH}): {str(primary_error)}")
+            
+            # Try fallback models
+            fallback_models = [
+                "google/flan-t5-base",
+                "google/flan-t5-small",
+                "facebook/bart-base",
+                "t5-small"
+            ]
+            
+            for fallback_model in fallback_models:
+                if fallback_model != MODEL_PATH:  # Skip if it's the same as the primary model
+                    try:
+                        logging.info(f"Trying fallback model: {fallback_model}")
+                        return load_with_retry(fallback_model)
+                    except Exception as fallback_error:
+                        logging.error(f"Failed to load fallback model ({fallback_model}): {str(fallback_error)}")
+            
+            # If all models fail, try a final tiny model
+            try:
+                logging.info("Trying final fallback to t5-small")
+                return load_with_retry("t5-small")
+            except Exception as final_error:
+                logging.error(f"All model loading attempts failed. Final error: {str(final_error)}")
+                st.error("Failed to load any model. Please check your internet connection and try again.")
+                return None, None
     
     def _initialize_local_model(self):
         """Initialize local model as fallback"""
         if self.model is None or self.tokenizer is None:
             self.model, self.tokenizer = self._load_model()
-            
+        
         if self.model is None or self.tokenizer is None:
-            raise ValueError("Failed to load model and tokenizer")
+            # Create a dummy model that returns a helpful message
+            logging.error("Failed to load any model. Creating a dummy model.")
+            return DummyModel()
             
         # Create a LocalHuggingFaceModel instance compatible with Agno
         return LocalHuggingFaceModel(self.model, self.tokenizer, max_length=512)
@@ -335,6 +436,28 @@ Output:"""
                 logging.error("Empty query provided")
                 return "Error: Please provide a non-empty query"
                 
+            # Check if models are available
+            if isinstance(self.translator, DummyModel) or isinstance(self.researcher, DummyModel) or \
+               isinstance(self.summarizer, DummyModel) or isinstance(self.presenter, DummyModel):
+                logging.error("One or more models are not available")
+                return """
+                # 🚨 Serviço Temporariamente Indisponível 🚨
+                
+                Desculpe, estamos enfrentando problemas de conexão com nossos serviços de modelo de linguagem.
+                
+                ## Possíveis causas:
+                - Problemas de conexão com a internet
+                - Servidores do Hugging Face podem estar sobrecarregados ou temporariamente indisponíveis
+                - Limitações de recursos do sistema
+                
+                ## O que você pode fazer:
+                - Tente novamente mais tarde
+                - Verifique sua conexão com a internet
+                - Entre em contato com o suporte se o problema persistir
+                
+                Agradecemos sua compreensão!
+                """
+                
             # Format translation prompt
             translation_prompt = self._format_prompt(
                 role="Translate the following text to English",