Update ai_logic.py

ai_logic.py

@@ -27,38 +27,25 @@ MODELS = {
 
 # Novos modelos para testar
 NEW_MODELS_TO_TEST = [
-    ("LLaMA 2-7B Chat", "meta-llama/Llama-2-7b-chat"),
+    ("LLaMA 2-7B Chat", "meta-llama/Llama-2-7b-chat-hf"),
     ("LLaMA 3.2-3B Instruct", "meta-llama/Llama-3.2-3B-Instruct"),
     ("Gemma 2B Instruct", "google/gemma-2b-it"),
     ("Qwen2 7B Instruct", "Qwen/Qwen2-7B-Instruct"),
     ("Falcon 7B Instruct", "tiiuae/falcon-7b-instruct"),
     ("Mixtral 8x7B Instruct", "mistralai/Mixtral-8x7B-Instruct-v0.1"),
     ("LLaMA 3.1-8B Instruct", "meta-llama/Llama-3.1-8B-Instruct"),
-    ("GPT2 XL", "gpt2-xl"),
-    ("T5 Base", "t5-base"),
-    ("Grok 2 Mini", "xAI/grok2-mini"),
     ("CodeLlama 7B Instruct", "codellama/CodeLlama-7b-Instruct-hf"),
-    ("Starling LM 7B", "HuggingFaceH4/starling-lm-7b-alpha"),
+    ("Starling LM 7B", "berkeley-nest/Starling-LM-7B-alpha"),
     ("OpenHermes 2.5 Mistral", "teknium/OpenHermes-2.5-Mistral-7B"),
-    ("Gemma 2B Instruct (Leve e Eficaz)", "google/gemma-2b-it"),
-    ("Qwen2 7B Instruct (Versátil)", "Qwen/Qwen2-7B-Instruct"),
-    ("OpenHermes 2.5 Mistral (Para Chat)", "teknium/OpenHermes-2.5-Mistral-7B"),
-    ("LLaMA 2-7B Chat (Requer aceitação de licença Meta)", "meta-llama/Llama-2-7b-chat"),
-    ("LLaMA 3.1-8B Instruct (Requer aceitação de licença Meta)", "meta-llama/Llama-3.1-8B-Instruct"),
-    ("Mistral 7B (Mais assertivo)", "mistralai/Mistral-7B-Instruct-v0.3"),
-    ("Phi-3 Mini (Mais rápido)", "microsoft/Phi-3-mini-4k-instruct"),
-    ("Zephyr 7B (Meio termo)", "HuggingFaceH4/zephyr-7b-beta"),
     ("Gemma 7B Instruct", "google/gemma-7b-it"),
     ("Qwen 2.5-7B Instruct", "Qwen/Qwen2.5-7B-Instruct"),
-    ("Falcon3-Mamba 7B Instruct", "tiiuae/Falcon3-Mamba-7B-Instruct"),
-    ("Dream 7B Instruct", "Dream-org/Dream-v0-Instruct-7B"),
-    ("OLMo 7B Instruct", "allenai/OLMo-7B-Instruct")
+    ("OLMo 7B Instruct", "allenai/OLMo-7B-Instruct-hf")
 ]
 DEFAULT_MODEL = "Mistral 7B (Mais acertivo)"
 
 # --- Gerenciamento de Sessão ---
-user_sessions: Dict[str, Dict[str, List | Dict]] = {}  # {session_id: {'conversation': [], 'user_profile': {}}}
-MAX_MEMORY_LENGTH = 5  # Máximo de trocas (user + assistant)
+user_sessions: Dict[str, Dict[str, List | Dict]] = {}
+MAX_MEMORY_LENGTH = 5
 
 def get_session_memory_path(session_id: str) -> str:
     """Retorna o caminho do arquivo de memória para a sessão."""
@@ -107,13 +94,11 @@ def update_user_profile(session_id: str, user_message: str):
     profile = user_sessions[session_id]['user_profile']
     message_lower = user_message.lower()
 
-    # Atualiza nível
     if any(word in message_lower for word in ['básico', 'iniciante']):
         profile['nivel'] = 'iniciante'
     elif any(word in message_lower for word in ['avançado', 'complexo']):
         profile['nivel'] = 'avançado'
 
-    # Atualiza interesses
     topics = {
         'java': ['java', 'classe', 'objeto'],
         'web': ['html', 'css', 'javascript'],
@@ -129,7 +114,7 @@ def update_user_profile(session_id: str, user_message: str):
 def get_conversation_context(session_id: str) -> str:
     """Gera o contexto da conversa recente."""
     load_conversation_memory(session_id)
-    conversation = user_sessions[session_id]['conversation'][-4:]  # Últimas 2 trocas
+    conversation = user_sessions[session_id]['conversation'][-4:]
     if not conversation:
         return ""
     return "\n".join(f"{msg['role'].upper()}: {msg['content']}" for msg in conversation)
@@ -231,34 +216,141 @@ class HuggingFaceAPIClient:
     def __init__(self, token: str):
         self.headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
 
+    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}"
+        try:
+            response = requests.get(url, headers=self.headers, timeout=10)
+            if response.status_code == 200:
+                model_info = response.json()
+                # Verifica se o modelo não está desabilitado
+                if model_info.get('disabled', False):
+                    return False, "Modelo desabilitado"
+                # Verifica se requer aprovação
+                if model_info.get('gated', False):
+                    return False, "Modelo requer aprovação/aceite de licença"
+                return True, "Modelo disponível"
+            elif response.status_code == 404:
+                return False, "Modelo não encontrado"
+            else:
+                return False, f"Erro HTTP {response.status_code}"
+        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."""
+        # Primeiro, tenta o endpoint de text-generation (mais comum)
+        url = f"https://api-inference.huggingface.co/models/{model_name}"
+        test_payload = {
+            "inputs": "Teste de disponibilidade do modelo.",
+            "parameters": {
+                "max_new_tokens": 10,
+                "temperature": 0.1,
+                "return_full_text": False
+            }
+        }
+        
+        try:
+            response = requests.post(url, headers=self.headers, json=test_payload, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                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}"
+            
+            elif response.status_code == 503:
+                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}"
+            elif response.status_code == 401:
+                return False, "Token inválido ou sem permissão"
+            elif response.status_code == 404:
+                return False, "Modelo não encontrado"
+            else:
+                return False, f"Erro HTTP {response.status_code}: {response.text}"
+                
+        except requests.exceptions.Timeout:
+            return False, "Timeout na requisição"
+        except requests.exceptions.RequestException as e:
+            return False, f"Erro na requisição: {str(e)}"
+
+    def test_model_availability(self, model_name: str) -> Tuple[bool, str]:
+        """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:
+            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:
+            print(f"  ✓ Inference check: {inference_msg}")
+            return True, f"Disponível - {info_msg}"
+        else:
+            print(f"  ✗ Inference check: {inference_msg}")
+            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 à API do Hugging Face."""
-        url = f"https://api-inference.huggingface.co/models/{model_name}/v1/chat/completions"
+        """Faz requisição ao modelo usando text-generation."""
+        # Converte mensagens para prompt simples
+        prompt = self._convert_messages_to_prompt(messages)
+        
+        url = f"https://api-inference.huggingface.co/models/{model_name}"
         payload = {
-            "model": model_name,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "temperature": 0.7
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": max_tokens,
+                "temperature": 0.7,
+                "do_sample": True,
+                "return_full_text": False
+            }
         }
+        
         try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=30)
+            response = requests.post(url, headers=self.headers, json=payload, timeout=60)
             response.raise_for_status()
-            return response.json()["choices"][0]["message"]["content"].strip()
+            
+            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}"
+                
         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)}"
 
-    def test_model_availability(self, model_name: str) -> Tuple[bool, str]:
-        """Testa se um modelo está disponível na API do Hugging Face."""
-        test_messages = [{"role": "user", "content": "Teste de disponibilidade."}]
-        try:
-            response = self.query_model(model_name, test_messages, max_tokens=10)
-            if response.startswith("Erro"):
-                return False, response
-            return True, "Modelo disponível."
-        except Exception as e:
-            return False, f"Erro ao testar modelo: {str(e)}"
+    def _convert_messages_to_prompt(self, messages: List[Dict]) -> str:
+        """Converte mensagens do formato chat para prompt simples."""
+        prompt_parts = []
+        for msg in messages:
+            role = msg['role']
+            content = msg['content']
+            
+            if role == 'system':
+                prompt_parts.append(f"Sistema: {content}")
+            elif role == 'user':
+                prompt_parts.append(f"Usuário: {content}")
+            elif role == 'assistant':
+                prompt_parts.append(f"Assistente: {content}")
+        
+        prompt_parts.append("Assistente:")
+        return "\n\n".join(prompt_parts)
 
 api_client = HuggingFaceAPIClient(HF_TOKEN)
 
@@ -266,28 +358,61 @@ api_client = HuggingFaceAPIClient(HF_TOKEN)
 def test_and_update_models():
     """Testa a disponibilidade dos novos modelos e atualiza a lista MODELS."""
     print("Testando disponibilidade dos novos modelos...")
+    print(f"Token HF disponível: {'Sim' if HF_TOKEN else 'Não'}")
+    print("-" * 60)
+    
     available_models = []
     unavailable_models = []
 
     for model_label, model_name in NEW_MODELS_TO_TEST:
         is_available, message = api_client.test_model_availability(model_name)
+        
         if is_available:
             MODELS[model_label] = model_name
             available_models.append((model_label, model_name, message))
+            print(f"✓ {model_label}")
         else:
             unavailable_models.append((model_label, model_name, message))
-
-    # Exibir resultados
-    print("\nResultados da validação:")
+            print(f"✗ {model_label} - {message}")
+        
+        # Pequena pausa para evitar rate limiting
+        time.sleep(1)
+
+    # Exibir resultados finais
+    print("\n" + "=" * 60)
+    print("RESULTADOS DA VALIDAÇÃO:")
+    print("=" * 60)
+    
     if available_models:
-        print("\nModelos disponíveis e adicionados:")
+        print(f"\n✓ MODELOS DISPONÍVEIS ({len(available_models)}):")
         for label, name, msg in available_models:
-            print(f"- {label} ({name}): {msg}")
+            print(f"  - {label}")
+            print(f"    {name}")
+            print(f"    Status: {msg}")
+            print()
+    
     if unavailable_models:
-        print("\nModelos não disponíveis:")
+        print(f"\n✗ MODELOS NÃO DISPONÍVEIS ({len(unavailable_models)}):")
         for label, name, msg in unavailable_models:
-            print(f"- {label} ({name}): {msg}")
-    print(f"\nTotal de modelos disponíveis em MODELS: {len(MODELS)}")
+            print(f"  - {label}")
+            print(f"    {name}")
+            print(f"    Motivo: {msg}")
+            print()
+    
+    print(f"TOTAL DE MODELOS DISPONÍVEIS: {len(MODELS)}")
+    print("=" * 60)
+    
+    # Salva a lista atualizada de modelos
+    save_updated_models()
+
+def save_updated_models():
+    """Salva a lista atualizada de modelos em um arquivo."""
+    try:
+        with open("models_available.json", "w", encoding="utf-8") as f:
+            json.dump(MODELS, f, ensure_ascii=False, indent=2)
+        print("Lista de modelos disponíveis salva em 'models_available.json'")
+    except Exception as e:
+        print(f"Erro ao salvar lista de modelos: {e}")
 
 # --- Chat Principal ---
 def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MODEL) -> str:
@@ -344,7 +469,13 @@ def inicializar_sistema():
 
 if __name__ == "__main__": 
     inicializar_sistema()
+    # Teste básico
     session_id = "teste_123"
+    print("\n" + "="*50)
+    print("TESTE DO CHATBOT:")
+    print("="*50)
     print(responder_como_aldo(session_id, "O que é Java?"))
+    print("\n" + "-"*50)
     print(responder_como_aldo(session_id, "Mostre um exemplo de código Java."))
+    print("\n" + "-"*50)
     print(clear_memory(session_id))