Update ai_logic.py

ai_logic.py

@@ -16,94 +16,33 @@ BLOG_URL = "https://aldohenrique.com.br/"
 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 ")
 
-# Lista inicial de modelos 
-NEW_MODELS_TO_TEST = [
-    ("Microsoft DialoGPT", "microsoft/DialoGPT-medium")]
-
-# --- Função para buscar modelos ---
-headers = {
-    "Authorization": f"Bearer {HF_TOKEN}"
-}
-
-# Modelos fixos que você quer manter
-MODELS = {
-    "Microsoft DialoGPT": "microsoft/DialoGPT-medium",
-    "Google T5 Small": "google/flan-t5-small",
-    "Google T5 Base": "google/flan-t5-base",
-    "Facebook BART": "facebook/bart-base",
-    "TinyLlama 1B": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
-    "Phi-3 Mini": "microsoft/Phi-3-mini-4k-instruct",
-    "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Llama 1B": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
-    "IBM 2B": "ibm-granite/granite-speech-3.3-2b",
-    "IBM 8B": "ibm-granite/granite-speech-3.3-8b",
-    "Phi-3 Mini (Mais rápido)": "microsoft/Phi-3-mini-4k-instruct",
-    "Zephyr 7B (Meio Termo)": "HuggingFaceH4/zephyr-7b-beta",
-    "Microsoft 8B (Meio Termo)": "meta-llama/Meta-Llama-3-8B-Instruct",
-    "Mistral-7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "DialoGPT": "microsoft/DialoGPT-medium",
-    "Google": "google/flan-t5-base",
-    "Facebook": "facebook/bart-large-cnn"
-}
-# --- 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
-    }
-    
-    try:
-        response = requests.get(url, headers=headers, params=params, timeout=30)
-        
-        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()
+# Validação do token com mensagem mais clara
+if not HF_TOKEN:
+    print("ERRO: Token HF_TOKEN não encontrado!")
+    print("Execute: export HF_TOKEN='seu_token_aqui' ou defina como variável de ambiente")
+    exit(1)
 
-print("Lista atualizada de modelos:\n")
-for name, model_id in NEW_MODELS_TO_TEST[:10]:  # Mostra apenas os primeiros 10
-    print(f'("{name}", "{model_id}"),')
+print(f"Token HF encontrado: {HF_TOKEN[:10]}...")
 
-print(f"\nTotal de modelos na lista: {len(NEW_MODELS_TO_TEST)}")
+# --- Modelos para teste (versão simplificada e mais robusta) ---
+MODELS = {}
 
-DEFAULT_MODEL = "Zephyr 7B (Meio Termo)"
+# Lista de modelos mais estáveis e com maior chance de funcionar
+NEW_MODELS_TO_TEST = [
+    ("GPT-2", "gpt2"),
+    ("DistilGPT-2", "distilgpt2"),
+    ("GPT-2 Medium", "gpt2-medium"),
+    ("Microsoft DialoGPT", "microsoft/DialoGPT-medium"),
+    ("Google T5 Small", "google/flan-t5-small"),
+    ("Google T5 Base", "google/flan-t5-base"),
+    ("Facebook BART", "facebook/bart-base"),
+    ("TinyLlama 1B", "TinyLlama/TinyLlama-1.1B-Chat-v1.0"),
+    ("Phi-3 Mini", "microsoft/Phi-3-mini-4k-instruct"),
+    ("Mistral 7B", "mistralai/Mistral-7B-Instruct-v0.3"),
+]
+
+DEFAULT_MODEL = "GPT-2"
 
 # --- Gerenciamento de Sessão ---
 user_sessions: Dict[str, Dict[str, List | Dict]] = {}
@@ -238,29 +177,43 @@ def scrape_text_from_url(url: str) -> str:
 def build_and_save_vector_store():
     """Constrói e salva o vector store."""
     global vector_store
-    links = get_all_blog_links(BLOG_URL)
-    texts = [scrape_text_from_url(link) for link in links if scrape_text_from_url(link)]
-    if not texts:
-        return "Nenhum conteúdo encontrado."
+    print("Construindo vector store...")
+    try:
+        links = get_all_blog_links(BLOG_URL)
+        texts = [scrape_text_from_url(link) for link in links if scrape_text_from_url(link)]
+        if not texts:
+            print("Nenhum conteúdo encontrado no blog.")
+            return "Nenhum conteúdo encontrado."
+            
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+        chunks = text_splitter.create_documents(texts)
+        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+        vector_store = FAISS.from_documents(chunks, embeddings)
         
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
-    chunks = text_splitter.create_documents(texts)
-    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    vector_store = FAISS.from_documents(chunks, embeddings)
-    
-    with open(VECTOR_STORE_PATH, "wb") as f:
-        pickle.dump(vector_store, f)
-    with open(PROCESSED_URLS_PATH, "wb") as f:
-        pickle.dump(links, f)
-    return f"Vector store criado com {len(chunks)} chunks."
+        with open(VECTOR_STORE_PATH, "wb") as f:
+            pickle.dump(vector_store, f)
+        with open(PROCESSED_URLS_PATH, "wb") as f:
+            pickle.dump(links, f)
+        print(f"Vector store criado com {len(chunks)} chunks.")
+        return f"Vector store criado com {len(chunks)} chunks."
+    except Exception as e:
+        print(f"Erro ao construir vector store: {e}")
+        return f"Erro ao construir vector store: {e}"
 
 def load_vector_store():
     """Carrega o vector store."""
     global vector_store
-    if os.path.exists(VECTOR_STORE_PATH):
-        with open(VECTOR_STORE_PATH, "rb") as f:
-            vector_store = pickle.load(f)
-    else:
+    try:
+        if os.path.exists(VECTOR_STORE_PATH):
+            with open(VECTOR_STORE_PATH, "rb") as f:
+                vector_store = pickle.load(f)
+            print("Vector store carregado com sucesso.")
+        else:
+            print("Vector store não encontrado. Criando novo...")
+            build_and_save_vector_store()
+    except Exception as e:
+        print(f"Erro ao carregar vector store: {e}")
+        print("Tentando criar novo vector store...")
         build_and_save_vector_store()
 
 def retrieve_context_from_blog(query: str, k: int = 4) -> str:
@@ -273,368 +226,174 @@ def retrieve_context_from_blog(query: str, k: int = 4) -> str:
             print(f"Erro ao buscar contexto: {e}")
     return ""
 
-# --- API Client ---
+# --- API Client (Versão Melhorada) ---
 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"
+        self.headers = {"Authorization": f"Bearer {token}"}
+        self.base_url = "https://api-inference.huggingface.co/models/"
 
-    def check_model_info(self, model_name: str) -> Tuple[bool, str]:
-        """Verifica informações do modelo via API do Hugging Face."""
-        url = f"{self.base_info_url}/{model_name}"
-        try:
-            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"{self.base_api_url}/{model_name}"
+    def check_model_status(self, model_name: str) -> Tuple[bool, str]:
+        """Verifica se um modelo está disponível via API."""
+        url = f"{self.base_url}{model_name}"
         
-        # Payload simplificado para teste
+        # Teste simples para verificar se o modelo responde
         test_payload = {
             "inputs": "Hello",
             "parameters": {
                 "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=60)
+            print(f"  Testando {model_name}...")
+            response = requests.post(url, headers=self.headers, json=test_payload, timeout=30)
             
             if response.status_code == 200:
                 result = response.json()
-                
-                # Verifica diferentes formatos de resposta
                 if isinstance(result, list) and len(result) > 0:
-                    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]}"
+                    return True, "Modelo disponível"
+                elif isinstance(result, dict) and 'generated_text' in result:
+                    return True, "Modelo disponível"
+                else:
+                    return False, f"Resposta inesperada: {result}"
                     
             elif response.status_code == 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:
-                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"
-                    
+                return False, "Modelo carregando (503)"
             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, "Endpoint do modelo não encontrado"
-            elif response.status_code == 429:
-                return False, "Limite de requisições excedido"
+                return False, "Token inválido (401)"
+            elif response.status_code == 400:
+                error_msg = response.json().get('error', 'Erro desconhecido')
+                if 'loading' in error_msg.lower():
+                    return False, "Modelo carregando"
+                return False, f"Erro 400: {error_msg}"
             else:
-                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]}"
+                return False, f"HTTP {response.status_code}: {response.text[:100]}"
                 
         except requests.exceptions.Timeout:
-            return False, "Timeout na requisição de inferência"
+            return False, "Timeout"
         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:
-            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:
-            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}"
+            return False, f"Erro de conexão: {str(e)[:100]}"
+        except Exception as e:
+            return False, f"Erro inesperado: {str(e)[:100]}"
 
-    def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
-        """Faz requisição ao modelo usando text-generation com retry e fallback."""
+    def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 500) -> str:
+        """Faz requisição ao modelo."""
+        # Converte mensagens para formato de prompt simples
         prompt = self._convert_messages_to_prompt(messages)
         
-        url = f"{self.base_api_url}/{model_name}"
-        
-        # Configurações otimizadas para diferentes tipos de modelo
+        url = f"{self.base_url}{model_name}"
         payload = {
             "inputs": prompt,
             "parameters": {
-                "max_new_tokens": min(max_tokens, 500),  # Limita para evitar timeouts
+                "max_new_tokens": max_tokens,
                 "temperature": 0.7,
-                "top_p": 0.9,
                 "do_sample": True,
-                "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
+                "return_full_text": False
             }
         }
         
-        max_retries = 2
-        for attempt in range(max_retries):
-            try:
-                response = requests.post(
-                    url, 
-                    headers=self.headers, 
-                    json=payload, 
-                    timeout=120  # Timeout aumentado
-                )
-                
-                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"
-                
+        try:
+            response = requests.post(url, headers=self.headers, json=payload, timeout=60)
+            
+            if response.status_code == 200:
+                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:
-                    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"
+                    return f"Formato de resposta inesperado: {result}"
+            else:
+                return f"Erro na requisição: {response.status_code} - {response.text[:200]}"
                 
-            except requests.exceptions.RequestException as e:
-                return f"Erro na requisição: {str(e)}"
-        
-        return "Falha após múltiplas tentativas"
+        except Exception as e:
+            return f"Erro ao consultar modelo: {str(e)}"
 
     def _convert_messages_to_prompt(self, messages: List[Dict]) -> str:
-        """Converte mensagens do formato chat para prompt otimizado."""
+        """Converte mensagens para prompt simples."""
         prompt_parts = []
-        
         for msg in messages:
             role = msg['role']
             content = msg['content']
             
             if role == 'system':
-                prompt_parts.append(f"### Sistema:\n{content}\n")
+                prompt_parts.append(f"Sistema: {content}")
             elif role == 'user':
-                prompt_parts.append(f"### Usuário:\n{content}\n")
+                prompt_parts.append(f"Usuário: {content}")
             elif role == 'assistant':
-                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)
+                prompt_parts.append(f"Assistente: {content}")
+                
+        prompt_parts.append("Assistente:")
+        return "\n\n".join(prompt_parts)
 
 # --- Função para Testar e Atualizar Modelos ---
 def test_and_update_models() -> int:
-    """
-    Testa a disponibilidade dos novos modelos e atualiza a lista MODELS.
-    Garante que o DEFAULT_MODEL seja sempre o primeiro da lista.
-    Retorna o número de modelos disponíveis.
-    """
+    """Testa modelos e atualiza a lista MODELS."""
     print("Testando disponibilidade dos modelos...")
     print(f"Token HF disponível: {'Sim' if HF_TOKEN else 'Não'}")
     print("-" * 60)
     
-    # Cria um dicionário temporário para os modelos disponíveis
-    temp_models = {}
-    
-    # Primeiro verifica o modelo padrão
-    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:
-        temp_models[default_label] = default_name
-        print(f"✓ {default_label} (DEFAULT MODEL)")
-    else:
-        print(f"✗ {default_label} - {message} (MODELO PADRÃO INDISPONÍVEL)")
-    
-    # Depois verifica os outros modelos (limitando a quantidade para evitar rate limiting)
-    tested_count = 0
-    max_tests = 15  # Limita o número de testes
+    api_client = HuggingFaceAPIClient(HF_TOKEN)
+    available_models = {}
     
     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
+        try:
+            is_available, message = api_client.check_model_status(model_name)
             
-        is_available, message = api_client.test_model_availability(model_name)
-        
-        if is_available:
-            temp_models[model_label] = model_name
-            print(f"✓ {model_label}")
-        else:
-            print(f"✗ {model_label} - {message}")
+            if is_available:
+                available_models[model_label] = model_name
+                print(f"✓ {model_label} - {message}")
+            else:
+                print(f"✗ {model_label} - {message}")
+                
+        except Exception as e:
+            print(f"✗ {model_label} - Erro: {str(e)}")
             
-        tested_count += 1
-        time.sleep(2)  # Pausa entre testes para evitar rate limiting
+        # Pausa para evitar rate limiting
+        time.sleep(2)
     
-    # Atualiza MODELS garantindo que o padrão seja o primeiro
+    # Atualiza MODELS
     global MODELS
     MODELS.clear()
-    
-    # Adiciona primeiro o modelo padrão (se disponível)
-    if default_label in temp_models:
-        MODELS[default_label] = temp_models.pop(default_label)
-    
-    # Adiciona os demais modelos
-    MODELS.update(temp_models)
+    MODELS.update(available_models)
     
     print("\n" + "=" * 60)
-    print("MODELOS DISPONÍVEIS (ORDEM):")
+    print("MODELOS DISPONÍVEIS:")
     print("=" * 60)
     for i, (label, name) in enumerate(MODELS.items(), 1):
-        print(f"{i}. {label}")
+        print(f"{i}. {label} ({name})")
     
-    print(f"\nTOTAL DE MODELOS DISPONÍVEIS: {len(MODELS)}")
+    print(f"\nTOTAL: {len(MODELS)} modelos disponíveis")
     print("=" * 60)
     
-    save_updated_models()
-    return len(MODELS)
-
-def save_updated_models():
-    """Salva a lista atualizada de modelos em um arquivo."""
+    # Salva lista atualizada
     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'")
+        print("Lista salva em 'models_available.json'")
     except Exception as e:
-        print(f"Erro ao salvar lista de modelos: {e}")
+        print(f"Erro ao salvar lista: {e}")
+    
+    return len(MODELS)
 
 # --- 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."
+    
+    # Usar primeiro modelo disponível se nenhum especificado
+    if not modelo or modelo not in MODELS:
+        if not MODELS:
+            return "Erro: Nenhum modelo disponível!"
+        modelo = list(MODELS.keys())[0]
         
     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}")
@@ -644,70 +403,97 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
         contexto.append(f"**Contexto do Blog**\n{blog}")
         
     system_prompt = """Você é o Dr. Aldo Henrique, 
-        Doutor em Ciências da Computação pela UnB (2024), mestre em Ciências da Computação pela UnB (2017) e bacharel em Sistemas de Informação pela UFV (2014). 
-        Professor universitário, onde leciona disciplinas como Algoritmos, Inteligência Artificial, Ciência de Dados e Mineração de Dados. 
-        Atua como analista de sistemas nível 4. 
-        Regras de conduta:
-        - Sempre coloque uma piada ou trocadilho no final da resposta.
-        - Responda em português, de forma clara, amigável e educativa.
-        - Explique conceitos antes de mostrar soluções.
-        - Use exemplos práticos.
-        - Considere o nível do usuário (iniciante, intermediário ou avançado).
-        - Use Markdown para formatar respostas, com ``` para blocos de código.
-        - Dentro do código sempre coloque comentários explicando para o alunos aprender com os comentários.
-        - Foque em tecnologia; se a pergunta for fora do escopo, informe educadamente que não é seu domínio.
+        Doutor em Ciências da Computação pela UnB (2024), professor universitário especializado em:
+        - Algoritmos e Estruturas de Dados
+        - Inteligência Artificial
+        - Ciência de Dados e Mineração de Dados
+        - Desenvolvimento de Software
+        
+        Responda sempre em português, de forma didática e clara.
+        - Explique conceitos antes de mostrar código
+        - Use exemplos práticos
+        - Considere o nível do usuário
+        - Termine sempre com uma piada ou trocadilho relacionado ao tema
+        - Use Markdown para formatação
+        - Adicione comentários explicativos no código
     """
     
     conteudo_contexto = "\n".join(contexto)
-    mensagem_usuario = f"{conteudo_contexto}\n\n**Pergunta**: {pergunta}"
+    mensagem_usuario = f"{conteudo_contexto}\n\n**Pergunta**: {pergunta}" if contexto else pergunta
 
     messages = [
         {"role": "system", "content": system_prompt},
         {"role": "user", "content": mensagem_usuario}
     ]
     
-    # 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")
+    # Faz requisição
+    api_client = HuggingFaceAPIClient(HF_TOKEN)
+    model_name = MODELS[modelo]
     resposta = api_client.query_model(model_name, messages)
+    
+    # Salva na memória
     add_to_memory(session_id, pergunta, resposta)
     return resposta
 
 # --- Inicialização ---
 def inicializar_sistema():
-    """
-    Inicializa o sistema, garantindo no mínimo 1 modelo disponível.
-    Retorna uma tupla: (status: bool, models: dict)
-    - status: True se >= 1 modelo disponível, False caso contrário
-    - models: Dicionário com os modelos disponíveis
-    """
+    """Inicializa o sistema."""
     print("Inicializando Chatbot Dr. Aldo...")
+    print("=" * 50)
     
+    # Testa modelos
     num_available_models = test_and_update_models()
     
     if num_available_models >= 1:
-        load_vector_store()
-        print("Sistema inicializado e pronto para uso com modelos suficientes!")
+        print(f"\n✓ Sistema inicializado com {num_available_models} modelos!")
+        
+        # Carrega vector store (opcional)
+        try:
+            load_vector_store()
+            print("✓ Vector store carregado!")
+        except Exception as e:
+            print(f"⚠ Erro ao carregar vector store: {e}")
+            print("⚠ Sistema funcionará sem contexto do blog.")
+        
         return True, MODELS
     else:
-        print(f"Erro: Apenas {num_available_models} modelos disponíveis. É necessário pelo menos 1 modelo para iniciar o sistema.")
+        print(f"\n✗ Erro: Nenhum modelo disponível!")
+        print("Verifique:")
+        print("1. Conexão com internet")
+        print("2. Token HF_TOKEN válido")
+        print("3. Permissões da conta Hugging Face")
         return False, MODELS
 
+# --- Execução Principal ---
 if __name__ == "__main__":
     status, models = inicializar_sistema()
+    
     if status:
         print("\n" + "="*50)
-        print("SISTEMA INICIADO: Realizando teste básico do Chatbot... ")
+        print("TESTE DO SISTEMA")
         print("="*50)
+        
         session_id = "teste_123"
-        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))
+        
+        # Teste 1
+        print("\n1. Testando pergunta básica...")
+        resposta1 = responder_como_aldo(session_id, "O que é Python?")
+        print(f"Resposta: {resposta1[:200]}...")
+        
+        # Teste 2
+        print("\n2. Testando pergunta com código...")
+        resposta2 = responder_como_aldo(session_id, "Mostre um exemplo de função em Python")
+        print(f"Resposta: {resposta2[:200]}...")
+        
+        # Limpeza
+        print(f"\n3. {clear_memory(session_id)}")
+        
+        print("\n" + "="*50)
+        print("SISTEMA PRONTO PARA USO!")
+        print("="*50)
+        
     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("\n" + "="*50)
+        print("SISTEMA NÃO PÔDE SER INICIALIZADO")
+        print("="*50)
+        print("Verifique as configurações e tente novamente.")