Update ai_logic.py

ai_logic.py

@@ -16,38 +16,37 @@ VECTOR_STORE_PATH = "faiss_index_store.pkl"
 PROCESSED_URLS_PATH = "processed_urls.pkl"
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
-    raise ValueError("Token HF_TOKEN não encontrado. Defina a variável de ambiente HF_TOKEN.")
+    raise ValueError("Token HF_TOKEN não encontrado")
 
-# Lista de todos os modelos que queremos testar.
-CANDIDATE_MODELS = {
-    # Originais
-    "Mistral 7B (Acertivo)": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Phi-3 Mini (Rápido)": "microsoft/Phi-3-mini-4k-instruct",
-    "Zephyr 7B (Equilibrado)": "HuggingFaceH4/zephyr-7b-beta",
-
-    # 13 Novos Modelos
-    "Gemma 2 9B (Google)": "google/gemma-2-9b-it",
-    "Llama 3 8B (Meta)": "meta-llama/Meta-Llama-3-8B-Instruct",
-    "Mixtral 8x7B (Mistral)": "mistralai/Mixtral-8x7B-Instruct-v0.1",
-    "Qwen2 7B (Alibaba)": "Qwen/Qwen2-7B-Instruct",
-    "Command R+ (Cohere)": "CohereForAI/c4ai-command-r-plus",
-    "Gemma 7B (Google)": "google/gemma-7b-it",
-    "Arctic (Snowflake)": "Snowflake/snowflake-arctic-instruct",
-    "OpenChat 3.5": "openchat/openchat-3.5-0106",
-    "Starling 7B (Nexus)": "Nexusflow/Starling-LM-7B-beta",
-    "Yi 1.5 9B (01-AI)": "01-ai/Yi-1.5-9B-Chat",
-    "CodeGemma 7B (Google)": "google/codegemma-7b-it",
-    "Heron 13B (Donako)": "Donako/heron-chat-13b",
-    "Stable Beluga 7B": "stabilityai/stable-beluga-7b"
+# Lista inicial de modelos
+MODELS = {
+    "Mistral 7B (Mais acertivo)": "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"
 }
 
-# Dicionário que será preenchido apenas com os modelos disponíveis
-MODELS = {}
-DEFAULT_MODEL = "Phi-3 Mini (Rápido)"
+# Novos modelos para testar
+NEW_MODELS_TO_TEST = [
+    ("LLaMA 2-7B Chat", "meta-llama/Llama-2-7b-chat"),
+    ("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"),
+    ("OpenHermes 2.5 Mistral", "teknium/OpenHermes-2.5-Mistral-7B")
+]
+
+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
+MAX_MEMORY_LENGTH = 5  # Máximo de trocas (user + assistant)
 
 def get_session_memory_path(session_id: str) -> str:
     """Retorna o caminho do arquivo de memória para a sessão."""
@@ -96,11 +95,13 @@ 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'],
@@ -116,7 +117,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:]
+    conversation = user_sessions[session_id]['conversation'][-4:]  # Últimas 2 trocas
     if not conversation:
         return ""
     return "\n".join(f"{msg['role'].upper()}: {msg['content']}" for msg in conversation)
@@ -148,19 +149,18 @@ def get_all_blog_links(url: str) -> set:
     """Coleta todos os links do blog."""
     links = {url}
     visited = set()
-    queue = [url]
-    while queue:
-        current_url = queue.pop(0)
+    while links:
+        current_url = links.pop()
         if current_url in visited:
             continue
         try:
-            response = requests.get(current_url, timeout=10)
+            response = requests.get(current_url, timeout=500)
             soup = BeautifulSoup(response.content, 'html.parser')
             visited.add(current_url)
             for link in soup.find_all('a', href=True):
                 href = urljoin(url, link['href'])
-                if urlparse(href).netloc == urlparse(url).netloc and '/tag/' not in href and '/category/' not in href and href not in visited:
-                    queue.append(href)
+                if urlparse(href).netloc == urlparse(url).netloc and '/tag/' not in href and '/category/' not in href:
+                    links.add(href)
         except Exception as e:
             print(f"Erro ao acessar {current_url}: {e}")
     return visited
@@ -168,7 +168,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=10)
+        response = requests.get(url, timeout=500)
         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 ""
@@ -221,11 +221,7 @@ class HuggingFaceAPIClient:
 
     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}"
-        # Para a nova API de chat
-        if "/v1/chat/completions" not in url:
-             url += "/v1/chat/completions"
-
+        url = f"https://api-inference.huggingface.co/models/{model_name}/v1/chat/completions"
         payload = {
             "model": model_name,
             "messages": messages,
@@ -233,65 +229,47 @@ class HuggingFaceAPIClient:
             "temperature": 0.7
         }
         try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=30)
+            response = requests.post(url, headers=self.headers, json=payload, timeout=10)
             response.raise_for_status()
             return response.json()["choices"][0]["message"]["content"].strip()
-        except requests.exceptions.RequestException as e:
-            # Captura erros de rede, timeout, HTTP etc.
-            print(f"Erro na requisição para o modelo {model_name}: {e}")
-            raise
-        except (KeyError, IndexError) as e:
-            # Captura erros na estrutura da resposta JSON
-            print(f"Resposta inesperada do modelo {model_name}: {response.text}")
-            raise
-
-api_client = HuggingFaceAPIClient(HF_TOKEN)
+        except Exception as e:
+            return f"Erro na API: {str(e)}"
 
-# --- Verificação de Modelos Disponíveis ---
-def verificar_modelos_disponiveis():
-    """
-    Testa cada modelo da lista de candidatos e popula o dicionário MODELS
-    apenas com aqueles que estão acessíveis e respondem.
-    """
-    global MODELS, DEFAULT_MODEL
-    print("Verificando a disponibilidade dos modelos do Hugging Face...")
-    
-    test_messages = [{"role": "user", "content": "Ping"}]
-    
-    for friendly_name, model_id in CANDIDATE_MODELS.items():
-        print(f"  - Testando: {friendly_name} ({model_id})... ", end="")
+    def test_model_availability(self, model_name: str) -> bool:
+        """Testa se um modelo está disponível na API do Hugging Face."""
+        test_messages = [
+            {"role": "user", "content": "Teste de disponibilidade."}
+        ]
         try:
-            # Usamos um timeout curto e poucos tokens para um teste rápido
-            api_client.query_model(model_id, test_messages, max_tokens=5)
-            MODELS[friendly_name] = model_id
-            print("✅ Disponível!")
+            response = self.query_model(model_name, test_messages, max_tokens=10)
+            return not response.startswith("Erro na API")
         except Exception:
-            print("❌ Indisponível ou erro.")
-            
-    if not MODELS:
-        raise RuntimeError("Nenhum dos modelos configurados está disponível no momento. Verifique seu token HF_TOKEN e a disponibilidade dos modelos.")
+            return False
 
-    # Garante que o modelo padrão seja um que esteja disponível
-    if DEFAULT_MODEL not in MODELS:
-        # Pega o primeiro modelo da lista de disponíveis como novo padrão
-        new_default_key = next(iter(MODELS))
-        print(f"Aviso: O modelo padrão '{DEFAULT_MODEL}' não está disponível.")
-        print(f"Definindo '{new_default_key}' como o novo padrão.")
-        DEFAULT_MODEL = new_default_key
+api_client = HuggingFaceAPIClient(HF_TOKEN)
 
+# --- Função para Testar e Atualizar Modelos ---
+def test_and_update_models():
+    """Testa a disponibilidade dos novos modelos e atualiza a lista MODELS."""
+    print("Testando disponibilidade dos novos modelos...")
+    for model_label, model_name in NEW_MODELS_TO_TEST:
+        if api_client.test_model_availability(model_name):
+            MODELS[model_label] = model_name
+            print(f"Modelo {model_label} ({model_name}) adicionado à lista.")
+        else:
+            print(f"Modelo {model_label} ({model_name}) não disponível.")
+    print(f"Total de modelos disponíveis: {len(MODELS)}")
 
 # --- Chat Principal ---
-def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> str:
+def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MODEL) -> str:
     """Gera resposta como Dr. Aldo Henrique."""
-    if modelo is None:
-        modelo = DEFAULT_MODEL # Usa o padrão dinâmico
-
     if not pergunta.strip():
         return "Por favor, faça uma pergunta válida."
     
     load_conversation_memory(session_id)
     update_user_profile(session_id, pergunta)
     
+    # Monta contexto
     contexto = []
     if perfil := get_user_profile_context(session_id):
         contexto.append(f"**Perfil do Usuário**\n{perfil}")
@@ -323,39 +301,21 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> s
     ]
     
     model_name = MODELS.get(modelo, MODELS[DEFAULT_MODEL])
-    try:
-        resposta = api_client.query_model(model_name, messages)
-        add_to_memory(session_id, pergunta, resposta)
-        return resposta
-    except Exception as e:
-        return f"Desculpe, houve um erro ao processar sua solicitação com o modelo {modelo}. Detalhes: {e}"
-
+    resposta = api_client.query_model(model_name, messages)
+    add_to_memory(session_id, pergunta, resposta)
+    return resposta
 
 # --- Inicialização ---
 def inicializar_sistema():
     """Inicializa o sistema."""
     print("Inicializando Chatbot Dr. Aldo...")
-    verificar_modelos_disponiveis() # <-- NOVO: Verifica os modelos antes de continuar
+    test_and_update_models()  # Testa e atualiza modelos disponíveis
     load_vector_store()
-    print("\nSistema inicializado e pronto para uso!")
-    print(f"Modelos disponíveis: {list(MODELS.keys())}")
-    print(f"Modelo padrão: {DEFAULT_MODEL}")
-
+    print("Sistema inicializado!")
 
 if __name__ == "__main__": 
     inicializar_sistema()
-    
     session_id = "teste_123"
-    print("\n--- Testando o Chat ---")
-    
-    # Exemplo de pergunta
-    pergunta_teste = "O que é um Large Language Model (LLM) e como ele se difere da IA tradicional?"
-    print(f"\n[Usuário]: {pergunta_teste}")
-    
-    # A função agora usa o modelo padrão que foi verificado como disponível
-    resposta_aldo = responder_como_aldo(session_id, pergunta_teste) 
-    print(f"\n[Dr. Aldo]: {resposta_aldo}")
-    
-    # Limpando a memória da sessão de teste
-    print(f"\n--- Limpando Memória ---")
+    print(responder_como_aldo(session_id, "O que é Java?"))
+    print(responder_como_aldo(session_id, "Mostre um exemplo de código Java."))
     print(clear_memory(session_id))