Update ai_logic.py

ai_logic.py

@@ -14,23 +14,202 @@ from langchain_community.embeddings import HuggingFaceEmbeddings
 BLOG_URL = "https://aldohenrique.com.br/"
 VECTOR_STORE_PATH = "faiss_index_store.pkl"
 PROCESSED_URLS_PATH = "processed_urls.pkl"
+AVAILABLE_MODELS_PATH = "available_models.json"
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
     raise ValueError("Token HF_TOKEN não encontrado")
 
-
-MODELS = {
+# Lista expandida de modelos para testar
+CANDIDATE_MODELS = {
+    # Modelos originais
     "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"
+    "Zephyr 7B (Meio Termo)": "HuggingFaceH4/zephyr-7b-beta",
+    
+    # Novos modelos para testar
+    "Llama 2 7B Chat": "meta-llama/Llama-2-7b-chat-hf",
+    "Code Llama 7B": "codellama/CodeLlama-7b-Instruct-hf",
+    "Falcon 7B Instruct": "tiiuae/falcon-7b-instruct",
+    "Gemma 7B Instruct": "google/gemma-7b-it",
+    "Vicuna 7B": "lmsys/vicuna-7b-v1.5",
+    "OpenHermes 2.5": "teknium/OpenHermes-2.5-Mistral-7B",
+    "Neural Chat 7B": "Intel/neural-chat-7b-v3-3",
+    "Starling 7B": "Nexusflow/Starling-LM-7B-beta",
+    "Yi 6B Chat": "01-ai/Yi-6B-Chat",
+    "Qwen 7B Chat": "Qwen/Qwen-7B-Chat",
+    "Baichuan2 7B Chat": "baichuan-inc/Baichuan2-7B-Chat",
+    "ChatGLM3 6B": "THUDM/chatglm3-6b",
+    "InternLM 7B Chat": "internlm/internlm-chat-7b",
+    "Alpaca 7B": "chavinlo/alpaca-native",
+    "Orca Mini 7B": "microsoft/Orca-2-7b",
+    "WizardLM 7B": "WizardLM/WizardLM-7B-V1.0"
 }
 
+# Modelos disponíveis (será preenchido dinamicamente)
+MODELS = {}
+DEFAULT_MODEL = None
+
+class HuggingFaceAPIClient:
+    def __init__(self, token: str):
+        self.headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+    def test_model_availability(self, model_name: str) -> bool:
+        """Testa se um modelo está disponível na API do Hugging Face."""
+        url = f"https://api-inference.huggingface.co/models/{model_name}"
+        
+        try:
+            # Primeiro, verifica se o modelo existe
+            response = requests.get(url, headers=self.headers, timeout=10)
+            if response.status_code != 200:
+                print(f"❌ Modelo {model_name} não encontrado (Status: {response.status_code})")
+                return False
+            
+            # Testa uma requisição simples de chat
+            chat_url = f"{url}/v1/chat/completions"
+            test_payload = {
+                "model": model_name,
+                "messages": [{"role": "user", "content": "Hello"}],
+                "max_tokens": 10,
+                "temperature": 0.1
+            }
+            
+            chat_response = requests.post(
+                chat_url, 
+                headers=self.headers, 
+                json=test_payload, 
+                timeout=30
+            )
+            
+            if chat_response.status_code == 200:
+                result = chat_response.json()
+                if "choices" in result and len(result["choices"]) > 0:
+                    print(f"✅ Modelo {model_name} disponível e funcionando")
+                    return True
+                else:
+                    print(f"⚠️ Modelo {model_name} retornou resposta inválida")
+                    return False
+            else:
+                print(f"❌ Modelo {model_name} indisponível (Status: {chat_response.status_code})")
+                return False
+                
+        except requests.exceptions.Timeout:
+            print(f"⏰ Timeout ao testar modelo {model_name}")
+            return False
+        except requests.exceptions.RequestException as e:
+            print(f"❌ Erro de conexão ao testar modelo {model_name}: {e}")
+            return False
+        except Exception as e:
+            print(f"❌ Erro inesperado ao testar modelo {model_name}: {e}")
+            return False
+
+    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"
+        payload = {
+            "model": model_name,
+            "messages": messages,
+            "max_tokens": max_tokens,
+            "temperature": 0.7
+        }
+        try:
+            response = requests.post(url, headers=self.headers, json=payload, timeout=60)
+            response.raise_for_status()
+            return response.json()["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            return f"Erro na API: {str(e)}"
+
+def check_and_update_available_models() -> Dict[str, str]:
+    """Verifica quais modelos estão disponíveis e atualiza a lista."""
+    print("🔍 Verificando disponibilidade dos modelos...")
+    print("=" * 60)
+    
+    api_client = HuggingFaceAPIClient(HF_TOKEN)
+    available_models = {}
+    
+    for display_name, model_path in CANDIDATE_MODELS.items():
+        print(f"Testando: {display_name} ({model_path})")
+        
+        if api_client.test_model_availability(model_path):
+            available_models[display_name] = model_path
+            time.sleep(1)  # Pausa para evitar rate limit
+        else:
+            time.sleep(0.5)  # Pausa menor para modelos que falharam
+    
+    print("=" * 60)
+    print(f"✅ {len(available_models)} modelos disponíveis de {len(CANDIDATE_MODELS)} testados")
+    
+    # Salva a lista de modelos disponíveis
+    try:
+        with open(AVAILABLE_MODELS_PATH, 'w', encoding='utf-8') as f:
+            json.dump({
+                'models': available_models,
+                'last_updated': time.time(),
+                'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
+            }, f, ensure_ascii=False, indent=2)
+        print(f"💾 Lista de modelos salva em {AVAILABLE_MODELS_PATH}")
+    except Exception as e:
+        print(f"⚠️ Erro ao salvar lista de modelos: {e}")
+    
+    return available_models
+
+def load_available_models() -> Dict[str, str]:
+    """Carrega a lista de modelos disponíveis do arquivo."""
+    if os.path.exists(AVAILABLE_MODELS_PATH):
+        try:
+            with open(AVAILABLE_MODELS_PATH, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                
+            # Verifica se os dados não são muito antigos (24 horas)
+            if time.time() - data.get('last_updated', 0) < 86400:
+                print(f"📁 Carregando modelos disponíveis (última atualização: {data.get('timestamp', 'desconhecida')})")
+                return data.get('models', {})
+            else:
+                print("⏰ Lista de modelos desatualizada, verificando novamente...")
+                
+        except Exception as e:
+            print(f"⚠️ Erro ao carregar lista de modelos: {e}")
+    
+    return check_and_update_available_models()
+
+def initialize_models():
+    """Inicializa a lista de modelos disponíveis."""
+    global MODELS, DEFAULT_MODEL
+    
+    MODELS = load_available_models()
+    
+    if not MODELS:
+        print("⚠️ Nenhum modelo disponível! Verificando novamente...")
+        MODELS = check_and_update_available_models()
+    
+    if MODELS:
+        # Define o modelo padrão (prioriza Mistral se disponível)
+        if "Mistral 7B (Mais acertivo)" in MODELS:
+            DEFAULT_MODEL = "Mistral 7B (Mais acertivo)"
+        else:
+            DEFAULT_MODEL = list(MODELS.keys())[0]
+        
+        print(f"🎯 Modelo padrão definido: {DEFAULT_MODEL}")
+        print(f"📋 Modelos disponíveis:")
+        for i, model_name in enumerate(MODELS.keys(), 1):
+            print(f"   {i}. {model_name}")
+    else:
+        raise RuntimeError("❌ Nenhum modelo LLM está disponível!")
 
-DEFAULT_MODEL = "Mistral 7B (Mais acertivo)"
+def get_available_models() -> Dict[str, str]:
+    """Retorna a lista atual de modelos disponíveis."""
+    return MODELS.copy()
 
-# --- 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)
+def refresh_models():
+    """Força a verificação de modelos disponíveis."""
+    global MODELS, DEFAULT_MODEL
+    print("🔄 Atualizando lista de modelos...")
+    MODELS = check_and_update_available_models()
+    initialize_models()
+
+# --- Resto do código original (gerenciamento de sessão, RAG, etc.) ---
+
+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."""
@@ -79,13 +258,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'],
@@ -101,7 +278,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)
@@ -198,36 +375,19 @@ def retrieve_context_from_blog(query: str, k: int = 3) -> str:
             print(f"Erro ao buscar contexto: {e}")
     return ""
 
-# --- API Client ---
-class HuggingFaceAPIClient:
-    def __init__(self, token: str):
-        self.headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
-
-    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"
-        print(messages)
-        payload = {
-            "model": model_name,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "temperature": 0.7
-        }
-        try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=500)
-            response.raise_for_status()
-            return response.json()["choices"][0]["message"]["content"].strip()
-        except Exception as e:
-            return f"Erro na API: {str(e)}"
-
+# --- API Client (atualizado) ---
 api_client = HuggingFaceAPIClient(HF_TOKEN)
 
 # --- Chat Principal ---
-def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MODEL) -> str:
+def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> str:
     """Gera resposta como Dr. Aldo Henrique."""
     if not pergunta.strip():
         return "Por favor, faça uma pergunta válida."
     
+    # Se não especificou modelo ou modelo não disponível, usa o padrão
+    if not modelo or modelo not in MODELS:
+        modelo = DEFAULT_MODEL
+    
     load_conversation_memory(session_id)
     update_user_profile(session_id, pergunta)
     
@@ -258,11 +418,11 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
     mensagem_usuario = f"{conteudo_contexto}\n\n**Pergunta**: {pergunta}"
 
     messages = [
-    {"role": "system", "content": system_prompt},
-    {"role": "user", "content": mensagem_usuario}
-]
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": mensagem_usuario}
+    ]
     
-    model_name = MODELS.get(modelo, MODELS[DEFAULT_MODEL])
+    model_name = MODELS[modelo]
     resposta = api_client.query_model(model_name, messages)
     add_to_memory(session_id, pergunta, resposta)
     return resposta
@@ -270,13 +430,64 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
 # --- Inicialização ---
 def inicializar_sistema():
     """Inicializa o sistema."""
-    print("Inicializando Chatbot Dr. Aldo...")
+    print("🤖 Inicializando Chatbot Dr. Aldo...")
+    initialize_models()
     load_vector_store()
-    print("Sistema inicializado!")
+    print("✅ Sistema inicializado com sucesso!")
+    print(f"🎯 Modelo padrão: {DEFAULT_MODEL}")
+    print(f"📊 Total de modelos disponíveis: {len(MODELS)}")
+
+# --- Funções auxiliares para gerenciamento ---
+def listar_modelos():
+    """Lista todos os modelos disponíveis."""
+    print("\n📋 Modelos LLM Disponíveis:")
+    print("=" * 50)
+    for i, (nome, caminho) in enumerate(MODELS.items(), 1):
+        status = "🎯 PADRÃO" if nome == DEFAULT_MODEL else ""
+        print(f"{i:2d}. {nome} {status}")
+        print(f"    └─ {caminho}")
+    print("=" * 50)
+
+def verificar_status_modelo(modelo_nome: str):
+    """Verifica o status de um modelo específico."""
+    if modelo_nome in MODELS:
+        print(f"✅ {modelo_nome} está disponível")
+        return True
+    else:
+        print(f"❌ {modelo_nome} não está disponível")
+        return False
 
 if __name__ == "__main__": 
     inicializar_sistema()
+    
+    # Exemplo de uso
+    listar_modelos()
+    
     session_id = "teste_123"
-    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))
+    print("\n" + "="*60)
+    print("🧪 TESTE DE FUNCIONAMENTO")
+    print("="*60)
+    
+    # Testa com modelo padrão
+    print(f"\n🎯 Testando com modelo padrão ({DEFAULT_MODEL}):")
+    resposta1 = responder_como_aldo(session_id, "O que é Java?")
+    print(f"Resposta: {resposta1[:200]}...")
+    
+    # Testa com outro modelo se disponível
+    modelos_disponiveis = list(MODELS.keys())
+    if len(modelos_disponiveis) > 1:
+        outro_modelo = modelos_disponiveis[1]
+        print(f"\n🔄 Testando com {outro_modelo}:")
+        resposta2 = responder_como_aldo(session_id, "Mostre um exemplo de código Java.", outro_modelo)
+        print(f"Resposta: {resposta2[:200]}...")
+    
+    print(f"\n🧹 {clear_memory(session_id)}")
+    
+    # Mostra comandos úteis
+    print("\n" + "="*60)
+    print("🛠️  COMANDOS ÚTEIS")
+    print("="*60)
+    print("- listar_modelos(): Lista todos os modelos disponíveis")
+    print("- refresh_models(): Atualiza a lista de modelos")
+    print("- verificar_status_modelo('nome'): Verifica se um modelo está disponível")
+    print("- get_available_models(): Retorna dicionário com modelos disponíveis")