Update ai_logic.py

ai_logic.py

@@ -29,7 +29,6 @@ headers = {
 
 # Modelos fixos que você quer manter
 NEW_MODELS_TO_TEST = [
-    
     ("GPT-2", "gpt2"),
     ("DistilGPT-2", "distilgpt2"),
     ("GPT-2 Medium", "gpt2-medium"),
@@ -52,44 +51,61 @@ NEW_MODELS_TO_TEST = [
     ("Facebook","facebook/bart-large-cnn")
 ]
 
-# --- Consulta a API da Hugging Face ---
-url = "https://huggingface.co/api/models?filter=text-generation,transformers,conversational,license:mit,text-generation-inference,safetensors,autotrain_compatible,endpoints_compatible,region:us"
-params = {
+# --- Consulta a API da Hugging Face com tratamento de erro melhorado ---
+def fetch_models_from_api():
+    """Busca modelos adicionais da API do Hugging Face com tratamento robusto."""
+    url = "https://huggingface.co/api/models"
+    params = {
+        "filter": "text-generation",
+        "sort": "downloads",
+        "direction": -1,
+        "limit": 20,
+        "full": True
+    }
     
-    "private":"false",
-    "limit": 1,  # Aumente se quiser trazer mais modelos
-    "full": "true"
-}
-
-response = requests.get(url, headers=headers, params=params)
-
-if response.status_code != 200:
-    raise Exception(f"Erro na API: {response.status_code} - {response.text}")
-
-models_data = response.json()
-
-# --- Filtra modelos que possuem base_model ---
-for model in models_data:
-    tags = model.get("tags", [])
-    base_model_tags = [tag for tag in tags if tag.startswith("base_model:")]
-    if base_model_tags:
-        model_name = model.get("id")
-        display_name = model_name.split("/")[-1]
+    try:
+        response = requests.get(url, headers=headers, params=params, timeout=30)
         
-        # Verifica se já não está na lista para evitar duplicados
-        if not any(model_name == m[1] for m in NEW_MODELS_TO_TEST):
-            NEW_MODELS_TO_TEST.append((display_name, model_name))
+        if response.status_code == 200:
+            models_data = response.json()
+            
+            # Filtra modelos que possuem base_model
+            for model in models_data:
+                try:
+                    tags = model.get("tags", [])
+                    model_name = model.get("id")
+                    
+                    if not model_name:
+                        continue
+                        
+                    # Verifica se o modelo é adequado
+                    if any(tag in tags for tag in ["text-generation", "conversational"]):
+                        display_name = model_name.split("/")[-1]
+                        
+                        # Verifica se já não está na lista para evitar duplicados
+                        if not any(model_name == m[1] for m in NEW_MODELS_TO_TEST):
+                            NEW_MODELS_TO_TEST.append((display_name, model_name))
+                            
+                except Exception as e:
+                    print(f"Erro ao processar modelo {model.get('id', 'unknown')}: {e}")
+                    continue
+                    
+        else:
+            print(f"Erro na API do Hugging Face: {response.status_code}")
+            
+    except Exception as e:
+        print(f"Erro ao buscar modelos da API: {e}")
+        print("Continuando com a lista de modelos predefinida...")
+
+# Executa a busca de modelos
+fetch_models_from_api()
 
-# --- Resultado ---
 print("Lista atualizada de modelos:\n")
-for name, model_id in NEW_MODELS_TO_TEST:
+for name, model_id in NEW_MODELS_TO_TEST[:10]:  # Mostra apenas os primeiros 10
     print(f'("{name}", "{model_id}"),')
 
 print(f"\nTotal de modelos na lista: {len(NEW_MODELS_TO_TEST)}")
 
-# Nota: Alguns modelos podem requerer aprovação ou ter restrições de acesso
-# Recomenda-se testar cada modelo individualmente para verificar disponibilidade
-
 DEFAULT_MODEL = "Zephyr 7B (Meio Termo)"
 
 # --- Gerenciamento de Sessão ---
@@ -200,7 +216,7 @@ def get_all_blog_links(url: str) -> set:
         if current_url in visited:
             continue
         try:
-            response = requests.get(current_url, timeout=500)
+            response = requests.get(current_url, timeout=10)
             soup = BeautifulSoup(response.content, 'html.parser')
             visited.add(current_url)
             for link in soup.find_all('a', href=True):
@@ -214,7 +230,7 @@ def get_all_blog_links(url: str) -> set:
 def scrape_text_from_url(url: str) -> str:
     """Extrai texto de uma URL."""
     try:
-        response = requests.get(url, timeout=500)
+        response = requests.get(url, timeout=10)
         soup = BeautifulSoup(response.content, 'html.parser')
         content = soup.find('article') or soup.find('main')
         return content.get_text(separator='\n', strip=True) if content else ""
@@ -264,66 +280,123 @@ def retrieve_context_from_blog(query: str, k: int = 4) -> str:
 class HuggingFaceAPIClient:
     def __init__(self, token: str):
         self.headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+        self.base_api_url = "https://api-inference.huggingface.co/models"
+        self.base_info_url = "https://huggingface.co/api/models"
 
     def check_model_info(self, model_name: str) -> Tuple[bool, str]:
         """Verifica informações do modelo via API do Hugging Face."""
-        url = f"https://huggingface.co/api/models/{model_name}"
+        url = f"{self.base_info_url}/{model_name}"
         try:
-            response = requests.get(url, headers=self.headers, timeout=90)
+            response = requests.get(url, headers=self.headers, timeout=15)
             if response.status_code == 200:
                 model_info = response.json()
+                
+                # Verifica se o modelo está desabilitado
                 if model_info.get('disabled', False):
                     return False, "Modelo desabilitado"
+                
+                # Verifica se o modelo requer aprovação
                 if model_info.get('gated', False):
                     return False, "Modelo requer aprovação/aceite de licença"
+                
+                # Verifica se o modelo existe mas não tem pipeline de text-generation
+                pipeline_tag = model_info.get('pipeline_tag')
+                if pipeline_tag and pipeline_tag not in ['text-generation', 'text2text-generation', 'conversational']:
+                    return False, f"Modelo não suporta geração de texto (pipeline: {pipeline_tag})"
+                
                 return True, "Modelo disponível"
+                
             elif response.status_code == 404:
                 return False, "Modelo não encontrado"
+            elif response.status_code == 401:
+                return False, "Token inválido ou sem permissão"
+            elif response.status_code == 403:
+                return False, "Acesso negado ao modelo"
             else:
                 return False, f"Erro HTTP {response.status_code}"
+                
+        except requests.exceptions.Timeout:
+            return False, "Timeout na verificação do modelo"
         except requests.exceptions.RequestException as e:
             return False, f"Erro na requisição: {str(e)}"
 
     def test_model_inference(self, model_name: str) -> Tuple[bool, str]:
         """Testa se o modelo está disponível para inferência."""
-        url = f"https://api-inference.huggingface.co/models/{model_name}"
+        url = f"{self.base_api_url}/{model_name}"
+        
+        # Payload simplificado para teste
         test_payload = {
-            "inputs": "Teste de disponibilidade do modelo.",
+            "inputs": "Hello",
             "parameters": {
-                "max_new_tokens": 10,
+                "max_new_tokens": 5,
                 "temperature": 0.1,
+                "do_sample": False,
                 "return_full_text": False
             }
         }
         
         try:
-            response = requests.post(url, headers=self.headers, json=test_payload, timeout=90)
+            response = requests.post(url, headers=self.headers, json=test_payload, timeout=60)
             
             if response.status_code == 200:
                 result = response.json()
+                
+                # Verifica diferentes formatos de resposta
                 if isinstance(result, list) and len(result) > 0:
-                    return True, "Modelo disponível para inferência"
-                elif isinstance(result, dict) and 'error' not in result:
-                    return True, "Modelo disponível para inferência"
-                else:
-                    return False, f"Resposta inesperada: {result}"
+                    if 'generated_text' in result[0] or 'translation_text' in result[0] or 'summary_text' in result[0]:
+                        return True, "Modelo disponível para inferência"
+                    
+                elif isinstance(result, dict):
+                    if 'generated_text' in result or 'error' not in result:
+                        return True, "Modelo disponível para inferência"
+                    elif 'error' in result:
+                        error_msg = result['error']
+                        if 'loading' in error_msg.lower() or 'currently loading' in error_msg.lower():
+                            return False, "Modelo está carregando"
+                        return False, f"Erro do modelo: {error_msg}"
+                
+                return False, f"Formato de resposta inesperado: {str(result)[:200]}"
                     
             elif response.status_code == 503:
-                return False, "Modelo está carregando (503)"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get('error', 'Serviço indisponível')
+                    if 'loading' in error_msg.lower():
+                        return False, "Modelo está carregando"
+                    return False, f"Serviço indisponível: {error_msg}"
+                except:
+                    return False, "Modelo está carregando (503)"
+                    
             elif response.status_code == 400:
-                error_msg = response.json().get('error', 'Erro 400')
-                if 'loading' in error_msg.lower():
-                    return False, "Modelo está carregando"
-                return False, f"Erro 400: {error_msg}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get('error', 'Erro 400')
+                    if 'loading' in error_msg.lower():
+                        return False, "Modelo está carregando"
+                    elif 'not supported' in error_msg.lower():
+                        return False, "Tipo de requisição não suportado"
+                    return False, f"Erro 400: {error_msg}"
+                except:
+                    return False, "Erro de requisição malformada"
+                    
             elif response.status_code == 401:
                 return False, "Token inválido ou sem permissão"
+            elif response.status_code == 403:
+                return False, "Acesso negado ao modelo"
             elif response.status_code == 404:
-                return False, "Modelo não encontrado"
+                return False, "Endpoint do modelo não encontrado"
+            elif response.status_code == 429:
+                return False, "Limite de requisições excedido"
             else:
-                return False, f"Erro HTTP {response.status_code}: {response.text}"
+                try:
+                    error_data = response.json()
+                    error_msg = error_data.get('error', response.text)
+                    return False, f"Erro HTTP {response.status_code}: {error_msg}"
+                except:
+                    return False, f"Erro HTTP {response.status_code}: {response.text[:200]}"
                 
         except requests.exceptions.Timeout:
-            return False, "Timeout na requisição"
+            return False, "Timeout na requisição de inferência"
         except requests.exceptions.RequestException as e:
             return False, f"Erro na requisição: {str(e)}"
 
@@ -331,12 +404,15 @@ class HuggingFaceAPIClient:
         """Testa se um modelo está disponível, combinando verificação de info e inferência."""
         print(f"Testando modelo: {model_name}")
         
+        # Primeiro verifica as informações do modelo
         info_available, info_msg = self.check_model_info(model_name)
         if not info_available:
+            print(f"  ✗ Info check: {info_msg}")
             return False, f"Info check failed: {info_msg}"
             
         print(f"  ✓ Info check: {info_msg}")
         
+        # Em seguida testa a inferência
         inference_available, inference_msg = self.test_model_inference(model_name)
         
         if inference_available:
@@ -347,53 +423,128 @@ class HuggingFaceAPIClient:
             return False, f"Não disponível para inferência: {inference_msg}"
 
     def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
-        """Faz requisição ao modelo usando text-generation."""
+        """Faz requisição ao modelo usando text-generation com retry e fallback."""
         prompt = self._convert_messages_to_prompt(messages)
         
-        url = f"https://api-inference.huggingface.co/models/{model_name}"
+        url = f"{self.base_api_url}/{model_name}"
+        
+        # Configurações otimizadas para diferentes tipos de modelo
         payload = {
             "inputs": prompt,
             "parameters": {
-                "max_new_tokens": max_tokens,
+                "max_new_tokens": min(max_tokens, 500),  # Limita para evitar timeouts
                 "temperature": 0.7,
+                "top_p": 0.9,
                 "do_sample": True,
-                "return_full_text": False
+                "return_full_text": False,
+                "repetition_penalty": 1.1,
+                "pad_token_id": 50256  # Token padrão para muitos modelos
+            },
+            "options": {
+                "wait_for_model": True,
+                "use_cache": False
             }
         }
         
-        try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=2500)
-            response.raise_for_status()
-            
-            result = response.json()
-            if isinstance(result, list) and len(result) > 0:
-                return result[0].get('generated_text', '').strip()
-            elif isinstance(result, dict) and 'generated_text' in result:
-                return result['generated_text'].strip()
-            else:
-                return f"Formato de resposta inesperado: {result}"
+        max_retries = 2
+        for attempt in range(max_retries):
+            try:
+                response = requests.post(
+                    url, 
+                    headers=self.headers, 
+                    json=payload, 
+                    timeout=120  # Timeout aumentado
+                )
                 
-        except requests.exceptions.HTTPError as http_err:
-            return f"Erro HTTP: {http_err.response.status_code} - {http_err.response.text}"
-        except requests.exceptions.RequestException as e:
-            return f"Erro na requisição: {str(e)}"
+                if response.status_code == 200:
+                    result = response.json()
+                    
+                    # Trata diferentes formatos de resposta
+                    if isinstance(result, list) and len(result) > 0:
+                        generated_text = result[0].get('generated_text', '').strip()
+                        if generated_text:
+                            return generated_text
+                        return "Resposta vazia do modelo"
+                        
+                    elif isinstance(result, dict):
+                        if 'generated_text' in result:
+                            return result['generated_text'].strip()
+                        elif 'error' in result:
+                            return f"Erro do modelo: {result['error']}"
+                        else:
+                            return f"Formato inesperado: {str(result)[:300]}"
+                    
+                    return f"Formato de resposta não reconhecido: {str(result)[:300]}"
+                
+                elif response.status_code == 503:
+                    if attempt < max_retries - 1:
+                        wait_time = 5 * (attempt + 1)
+                        print(f"Modelo carregando, aguardando {wait_time}s...")
+                        time.sleep(wait_time)
+                        continue
+                    return "Modelo ainda está carregando após várias tentativas"
+                
+                elif response.status_code == 400:
+                    try:
+                        error_data = response.json()
+                        error_msg = error_data.get('error', 'Erro 400')
+                        return f"Erro na requisição: {error_msg}"
+                    except:
+                        return "Erro na formatação da requisição"
+                
+                elif response.status_code == 401:
+                    return "Token de autenticação inválido ou expirado"
+                
+                elif response.status_code == 403:
+                    return "Acesso negado ao modelo (pode requerer aprovação)"
+                
+                elif response.status_code == 429:
+                    if attempt < max_retries - 1:
+                        wait_time = 10 * (attempt + 1)
+                        print(f"Rate limit atingido, aguardando {wait_time}s...")
+                        time.sleep(wait_time)
+                        continue
+                    return "Limite de requisições excedido"
+                
+                else:
+                    try:
+                        error_data = response.json()
+                        error_msg = error_data.get('error', response.text)
+                        return f"Erro HTTP {response.status_code}: {error_msg}"
+                    except:
+                        return f"Erro HTTP {response.status_code}: {response.text[:200]}"
+                        
+            except requests.exceptions.Timeout:
+                if attempt < max_retries - 1:
+                    print(f"Timeout na tentativa {attempt + 1}, tentando novamente...")
+                    time.sleep(5)
+                    continue
+                return "Timeout: O modelo demorou muito para responder"
+                
+            except requests.exceptions.RequestException as e:
+                return f"Erro na requisição: {str(e)}"
+        
+        return "Falha após múltiplas tentativas"
 
     def _convert_messages_to_prompt(self, messages: List[Dict]) -> str:
-        """Converte mensagens do formato chat para prompt simples."""
+        """Converte mensagens do formato chat para prompt otimizado."""
         prompt_parts = []
+        
         for msg in messages:
             role = msg['role']
             content = msg['content']
             
             if role == 'system':
-                prompt_parts.append(f"Sistema: {content}")
+                prompt_parts.append(f"### Sistema:\n{content}\n")
             elif role == 'user':
-                prompt_parts.append(f"Usuário: {content}")
+                prompt_parts.append(f"### Usuário:\n{content}\n")
             elif role == 'assistant':
-                prompt_parts.append(f"Assistente: {content}")
-                
-        prompt_parts.append("Assistente:")
-        return "\n\n".join(prompt_parts)
+                prompt_parts.append(f"### Assistente:\n{content}\n")
+        
+        # Adiciona prompt final para gerar resposta
+        prompt_parts.append("### Assistente:\n")
+        
+        return "\n".join(prompt_parts)
 
 api_client = HuggingFaceAPIClient(HF_TOKEN)
 
@@ -404,7 +555,7 @@ def test_and_update_models() -> int:
     Garante que o DEFAULT_MODEL seja sempre o primeiro da lista.
     Retorna o número de modelos disponíveis.
     """
-    print("Testando disponibilidade dos novos modelos...")
+    print("Testando disponibilidade dos modelos...")
     print(f"Token HF disponível: {'Sim' if HF_TOKEN else 'Não'}")
     print("-" * 60)
     
@@ -412,7 +563,9 @@ def test_and_update_models() -> int:
     temp_models = {}
     
     # Primeiro verifica o modelo padrão
-    default_label, default_name = "Mistral 7B (Mais acertivo)", "mistralai/Mistral-7B-Instruct-v0.3"
+    default_label = "Mistral 7B"
+    default_name = "mistralai/Mistral-7B-Instruct-v0.3"
+    
     is_available, message = api_client.test_model_availability(default_name)
     
     if is_available:
@@ -421,11 +574,17 @@ def test_and_update_models() -> int:
     else:
         print(f"✗ {default_label} - {message} (MODELO PADRÃO INDISPONÍVEL)")
     
-    # Depois verifica os outros modelos
+    # Depois verifica os outros modelos (limitando a quantidade para evitar rate limiting)
+    tested_count = 0
+    max_tests = 15  # Limita o número de testes
+    
     for model_label, model_name in NEW_MODELS_TO_TEST:
         # Pula o modelo padrão se já foi testado
         if model_label == default_label and model_name == default_name:
             continue
+        
+        if tested_count >= max_tests:
+            break
             
         is_available, message = api_client.test_model_availability(model_name)
         
@@ -435,7 +594,8 @@ def test_and_update_models() -> int:
         else:
             print(f"✗ {model_label} - {message}")
             
-        time.sleep(1)
+        tested_count += 1
+        time.sleep(2)  # Pausa entre testes para evitar rate limiting
     
     # Atualiza MODELS garantindo que o padrão seja o primeiro
     global MODELS
@@ -509,7 +669,11 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
         {"role": "user", "content": mensagem_usuario}
     ]
     
-    model_name = MODELS.get(modelo, MODELS[DEFAULT_MODEL])
+    # Verifica se o modelo existe na lista, senão usa o padrão
+    if modelo not in MODELS:
+        modelo = next(iter(MODELS)) if MODELS else DEFAULT_MODEL
+    
+    model_name = MODELS.get(modelo, list(MODELS.values())[0] if MODELS else "mistralai/Mistral-7B-Instruct-v0.3")
     resposta = api_client.query_model(model_name, messages)
     add_to_memory(session_id, pergunta, resposta)
     return resposta
@@ -517,9 +681,9 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
 # --- Inicialização ---
 def inicializar_sistema():
     """
-    Inicializa o sistema, garantindo no mínimo 3 modelos disponíveis.
+    Inicializa o sistema, garantindo no mínimo 1 modelo disponível.
     Retorna uma tupla: (status: bool, models: dict)
-    - status: True se >= 3 modelos disponíveis, False caso contrário
+    - status: True se >= 1 modelo disponível, False caso contrário
     - models: Dicionário com os modelos disponíveis
     """
     print("Inicializando Chatbot Dr. Aldo...")
@@ -531,7 +695,7 @@ def inicializar_sistema():
         print("Sistema inicializado e pronto para uso com modelos suficientes!")
         return True, MODELS
     else:
-        print(f"Erro: Apenas {num_available_models} modelos disponíveis. São necessários pelo menos 3 modelos para iniciar o sistema.")
+        print(f"Erro: Apenas {num_available_models} modelos disponíveis. É necessário pelo menos 1 modelo para iniciar o sistema.")
         return False, MODELS
 
 if __name__ == "__main__":
@@ -549,4 +713,4 @@ if __name__ == "__main__":
     else:
         print("\nSistema não pôde ser iniciado devido à falta de modelos suficientes.")
         print(f"Modelos disponíveis: {', '.join(models.keys()) if models else 'Nenhum'}")
-        print("Por favor, verifique a conexão com o Hugging Face e o token de acesso.")
+        print("Por favor, verifique a conexão com o Hugging Face e o token de acesso.")