Update ai_logic.py

ai_logic.py

@@ -9,75 +9,57 @@ from urllib.parse import urljoin, urlparse
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
 from langchain_community.embeddings import HuggingFaceEmbeddings
+import openai
+from groq import Groq
+import google.generativeai as genai
 
 # --- Configurações ---
 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 ")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")  # Para usar modelos gratuitos do OpenAI via outras APIs
 
-# Lista inicial de modelos 
-MODELS = {}
-
-# --- Função para buscar modelos ---
-headers = {
-    "Authorization": f"Bearer {HF_TOKEN}"
-}
-
-# Modelos fixos que você quer manter
+# Lista inicial de modelos HuggingFace
 NEW_MODELS_TO_TEST = [
     ("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")
+    ("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 ---
-url = "https://huggingface.co/api/models?filter=text-generation,transformers,conversational,license:mit,text-generation-inference,safetensors,autotrain_compatible,endpoints_compatible,region:us"
-params = {
+# Modelos alternativos gratuitos
+FALLBACK_MODELS = [
+    # Groq (gratuito com rate limit)
+    ("Llama 3 8B (Groq)", "llama3-8b-8192", "groq"),
+    ("Mixtral 8x7B (Groq)", "mixtral-8x7b-32768", "groq"),
+    ("Gemma 7B (Groq)", "gemma-7b-it", "groq"),
     
-    "private":"false",
-    "limit": 300,  # 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]
-        
-        # 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))
-
-# --- Resultado ---
-print("Lista atualizada de modelos:\n")
-for name, model_id in NEW_MODELS_TO_TEST:
-    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
+    # Google Gemini (gratuito com rate limit)
+    ("Gemini 1.5 Flash (Google)", "gemini-1.5-flash", "gemini"),
+    ("Gemini 1.5 Pro (Google)", "gemini-1.5-pro", "gemini"),
+    
+    # Cohere (gratuito com rate limit)
+    ("Command R+ (Cohere)", "command-r-plus", "cohere"),
+    
+    # Anthropic via outras APIs (quando disponível gratuitamente)
+    ("Claude 3 Haiku (Fallback)", "claude-3-haiku-20240307", "anthropic"),
+    
+    # Modelos via APIs públicas gratuitas
+    ("Llama 2 7B (Together)", "togethercomputer/llama-2-7b-chat", "together"),
+    ("CodeLlama 7B (Together)", "togethercomputer/CodeLlama-7b-Instruct", "together"),
+]
 
-DEFAULT_MODEL = "Zephyr 7B (Meio Termo)"
+# Dicionário unificado de modelos
+MODELS = {}
+DEFAULT_MODEL = "Phi-3 Mini (Mais rápido)"
 
-# --- Gerenciamento de Sessão ---
+# --- Gerenciamento de Sessão (mantido igual) ---
 user_sessions: Dict[str, Dict[str, List | Dict]] = {}
 MAX_MEMORY_LENGTH = 5
 
@@ -173,7 +155,7 @@ def clear_memory(session_id: str) -> str:
         os.remove(memory_path)
     return "Memória limpa com sucesso!"
 
-# --- RAG (Crawling e Vector Store) ---
+# --- RAG (Crawling e Vector Store) - Mantido igual ---
 vector_store: Optional[FAISS] = None
 
 def get_all_blog_links(url: str) -> set:
@@ -245,94 +227,25 @@ def retrieve_context_from_blog(query: str, k: int = 4) -> 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 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=90)
-            if response.status_code == 200:
-                model_info = response.json()
-                if model_info.get('disabled', False):
-                    return False, "Modelo desabilitado"
-                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."""
-        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
-            }
-        }
+# --- Classe Unificada de API Client ---
+class UnifiedAPIClient:
+    def __init__(self, hf_token: str = None, groq_api_key: str = None, gemini_api_key: str = None):
+        self.hf_token = hf_token
+        self.groq_api_key = groq_api_key
+        self.gemini_api_key = gemini_api_key
         
-        try:
-            response = requests.post(url, headers=self.headers, json=test_payload, timeout=90)
-            
-            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}")
-        
-        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}")
-        
-        inference_available, inference_msg = self.test_model_inference(model_name)
+        # Inicializa clientes
+        self.hf_headers = {"Authorization": f"Bearer {hf_token}", "Content-Type": "application/json"} if hf_token else None
+        self.groq_client = Groq(api_key=groq_api_key) if groq_api_key else None
         
-        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}"
+        if gemini_api_key:
+            genai.configure(api_key=gemini_api_key)
 
-    def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
-        """Faz requisição ao modelo usando text-generation."""
+    def query_huggingface(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta modelos do Hugging Face."""
+        if not self.hf_headers:
+            return "Token do Hugging Face não configurado"
+            
         prompt = self._convert_messages_to_prompt(messages)
         
         url = f"https://api-inference.huggingface.co/models/{model_name}"
@@ -347,7 +260,7 @@ class HuggingFaceAPIClient:
         }
         
         try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=2500)
+            response = requests.post(url, headers=self.hf_headers, json=payload, timeout=30)
             response.raise_for_status()
             
             result = response.json()
@@ -358,10 +271,171 @@ class HuggingFaceAPIClient:
             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)}"
+            return f"Erro na requisição HuggingFace: {str(e)}"
+
+    def query_groq(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta modelos do Groq."""
+        if not self.groq_client:
+            return "API Key do Groq não configurada"
+            
+        try:
+            # Converte mensagens para formato do Groq
+            groq_messages = []
+            for msg in messages:
+                groq_messages.append({
+                    "role": msg["role"],
+                    "content": msg["content"]
+                })
+            
+            response = self.groq_client.chat.completions.create(
+                model=model_name,
+                messages=groq_messages,
+                max_tokens=max_tokens,
+                temperature=0.7
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            return f"Erro na requisição Groq: {str(e)}"
+
+    def query_gemini(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta modelos do Google Gemini."""
+        if not self.gemini_api_key:
+            return "API Key do Gemini não configurada"
+            
+        try:
+            # Converte mensagens para formato do Gemini
+            conversation_text = ""
+            for msg in messages:
+                if msg["role"] == "system":
+                    conversation_text += f"Instrução: {msg['content']}\n\n"
+                elif msg["role"] == "user":
+                    conversation_text += f"Usuário: {msg['content']}\n\n"
+                elif msg["role"] == "assistant":
+                    conversation_text += f"Assistente: {msg['content']}\n\n"
+            
+            conversation_text += "Assistente:"
+            
+            model = genai.GenerativeModel(model_name)
+            response = model.generate_content(
+                conversation_text,
+                generation_config=genai.types.GenerationConfig(
+                    max_output_tokens=max_tokens,
+                    temperature=0.7
+                )
+            )
+            
+            return response.text.strip()
+            
+        except Exception as e:
+            return f"Erro na requisição Gemini: {str(e)}"
+
+    def query_cohere(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta modelos do Cohere via API pública."""
+        try:
+            # Converte mensagens para prompt
+            prompt = self._convert_messages_to_prompt(messages)
+            
+            # Usa API pública do Cohere (se disponível)
+            url = "https://api.cohere.ai/v1/generate"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {os.getenv('COHERE_API_KEY', 'demo-key')}"
+            }
+            
+            payload = {
+                "model": model_name,
+                "prompt": prompt,
+                "max_tokens": max_tokens,
+                "temperature": 0.7
+            }
+            
+            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("generations", [{}])[0].get("text", "").strip()
+            else:
+                return f"Erro Cohere: {response.status_code}"
+                
+        except Exception as e:
+            return f"Erro na requisição Cohere: {str(e)}"
+
+    def query_together(self, model_name: str, messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta modelos via Together AI (API pública)."""
+        try:
+            prompt = self._convert_messages_to_prompt(messages)
+            
+            # API do Together AI
+            url = "https://api.together.xyz/inference"
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {os.getenv('TOGETHER_API_KEY', 'demo-key')}"
+            }
+            
+            payload = {
+                "model": model_name,
+                "prompt": prompt,
+                "max_tokens": max_tokens,
+                "temperature": 0.7
+            }
+            
+            response = requests.post(url, headers=headers, json=payload, timeout=30)
+            
+            if response.status_code == 200:
+                result = response.json()
+                return result.get("output", {}).get("choices", [{}])[0].get("text", "").strip()
+            else:
+                return f"Erro Together: {response.status_code}"
+                
+        except Exception as e:
+            return f"Erro na requisição Together: {str(e)}"
+
+    def query_model(self, model_display_name: str, model_info: Tuple[str, str], messages: List[Dict], max_tokens: int = 1000) -> str:
+        """Consulta um modelo baseado no seu tipo/provedor."""
+        model_name, provider = model_info
+        
+        try:
+            if provider == "huggingface":
+                return self.query_huggingface(model_name, messages, max_tokens)
+            elif provider == "groq":
+                return self.query_groq(model_name, messages, max_tokens)
+            elif provider == "gemini":
+                return self.query_gemini(model_name, messages, max_tokens)
+            elif provider == "cohere":
+                return self.query_cohere(model_name, messages, max_tokens)
+            elif provider == "together":
+                return self.query_together(model_name, messages, max_tokens)
+            else:
+                return f"Provedor desconhecido: {provider}"
+                
+        except Exception as e:
+            return f"Erro ao consultar modelo {model_display_name}: {str(e)}"
+
+    def test_model_availability(self, model_name: str, provider: str) -> Tuple[bool, str]:
+        """Testa se um modelo está disponível."""
+        test_messages = [
+            {"role": "system", "content": "Você é um assistente útil."},
+            {"role": "user", "content": "Teste de disponibilidade. Responda apenas 'OK'."}
+        ]
+        
+        try:
+            response = self.query_model(
+                f"Teste {model_name}", 
+                (model_name, provider), 
+                test_messages, 
+                max_tokens=10
+            )
+            
+            if response and not response.startswith("Erro"):
+                return True, "Modelo disponível"
+            else:
+                return False, response
+                
+        except Exception as e:
+            return False, f"Erro no teste: {str(e)}"
 
     def _convert_messages_to_prompt(self, messages: List[Dict]) -> str:
         """Converte mensagens do formato chat para prompt simples."""
@@ -380,67 +454,70 @@ class HuggingFaceAPIClient:
         prompt_parts.append("Assistente:")
         return "\n\n".join(prompt_parts)
 
-api_client = HuggingFaceAPIClient(HF_TOKEN)
+# Inicializa o cliente unificado
+api_client = UnifiedAPIClient(HF_TOKEN, GROQ_API_KEY, GEMINI_API_KEY)
 
 # --- 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.
-    """
-    print("Testando disponibilidade dos novos 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 = {}
+    """Testa a disponibilidade de todos os modelos e atualiza a lista MODELS."""
+    print("Testando disponibilidade dos modelos...")
+    print(f"Tokens disponíveis: HF={bool(HF_TOKEN)}, Groq={bool(GROQ_API_KEY)}, Gemini={bool(GEMINI_API_KEY)}")
+    print("-" * 80)
     
-    # Primeiro verifica o modelo padrão
-    default_label, default_name = "Mistral 7B (Mais acertivo)", "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)")
+    global MODELS
+    MODELS.clear()
     
-    # Depois verifica os outros modelos
+    # Testa modelos do Hugging Face
+    print("🔍 TESTANDO MODELOS HUGGING FACE:")
     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:
+        if HF_TOKEN:
+            is_available, message = api_client.test_model_availability(model_name, "huggingface")
+            if is_available:
+                MODELS[model_label] = (model_name, "huggingface")
+                print(f"✅ {model_label}")
+            else:
+                print(f"❌ {model_label} - {message}")
+        else:
+            print(f"⚠️  {model_label} - Token HF não configurado")
+        time.sleep(1)
+    
+    # Testa modelos de fallback
+    print("\n🔍 TESTANDO MODELOS DE FALLBACK:")
+    for model_label, model_name, provider in FALLBACK_MODELS:
+        # Verifica se as credenciais estão disponíveis
+        if provider == "groq" and not GROQ_API_KEY:
+            print(f"⚠️  {model_label} - API Key Groq não configurada")
+            continue
+        elif provider == "gemini" and not GEMINI_API_KEY:
+            print(f"⚠️  {model_label} - API Key Gemini não configurada")
             continue
-            
-        is_available, message = api_client.test_model_availability(model_name)
         
+        is_available, message = api_client.test_model_availability(model_name, provider)
         if is_available:
-            temp_models[model_label] = model_name
-            print(f"✓ {model_label}")
+            MODELS[model_label] = (model_name, provider)
+            print(f"✅ {model_label} ({provider.upper()})")
         else:
-            print(f"✗ {model_label} - {message}")
-            
+            print(f"❌ {model_label} - {message}")
         time.sleep(1)
     
-    # Atualiza MODELS garantindo que o padrão seja o primeiro
-    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)
+    print("\n" + "=" * 80)
+    print("📊 RESUMO DOS MODELOS DISPONÍVEIS:")
+    print("=" * 80)
     
-    # Adiciona os demais modelos
-    MODELS.update(temp_models)
+    # Organiza por provedor
+    providers = {}
+    for label, (model_name, provider) in MODELS.items():
+        if provider not in providers:
+            providers[provider] = []
+        providers[provider].append(label)
     
-    print("\n" + "=" * 60)
-    print("MODELOS DISPONÍVEIS (ORDEM):")
-    print("=" * 60)
-    for i, (label, name) in enumerate(MODELS.items(), 1):
-        print(f"{i}. {label}")
+    for provider, models in providers.items():
+        print(f"\n🔹 {provider.upper()}:")
+        for i, model in enumerate(models, 1):
+            print(f"   {i}. {model}")
     
-    print(f"\nTOTAL DE MODELOS DISPONÍVEIS: {len(MODELS)}")
-    print("=" * 60)
+    print(f"\n🎯 TOTAL DE MODELOS DISPONÍVEIS: {len(MODELS)}")
+    print("=" * 80)
     
     save_updated_models()
     return len(MODELS)
@@ -448,18 +525,31 @@ def test_and_update_models() -> int:
 def save_updated_models():
     """Salva a lista atualizada de modelos em um arquivo."""
     try:
+        models_info = {}
+        for label, (model_name, provider) in MODELS.items():
+            models_info[label] = {
+                "model_name": model_name,
+                "provider": provider
+            }
+        
         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'")
+            json.dump(models_info, 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}")
+        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:
-    """Gera resposta como Dr. Aldo Henrique."""
+def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> str:
+    """Gera resposta como Dr. Aldo Henrique usando o modelo selecionado."""
     if not pergunta.strip():
         return "Por favor, faça uma pergunta válida."
-        
+    
+    # Seleciona modelo disponível
+    if not modelo or modelo not in MODELS:
+        if not MODELS:
+            return "❌ Nenhum modelo está disponível no momento. Verifique as configurações das APIs."
+        modelo = next(iter(MODELS.keys()))  # Pega o primeiro modelo disponível
+    
     load_conversation_memory(session_id)
     update_user_profile(session_id, pergunta)
     
@@ -483,7 +573,7 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = DEFAULT_MO
         - 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.
+        - Dentro do código sempre coloque comentários explicando para o aluno aprender com os comentários.
         - Foque em tecnologia; se a pergunta for fora do escopo, informe educadamente que não é seu domínio.
     """
     
@@ -495,44 +585,416 @@ 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])
-    resposta = api_client.query_model(model_name, messages)
-    add_to_memory(session_id, pergunta, resposta)
-    return resposta
+    # Obtém informações do modelo
+    model_info = MODELS[modelo]
+    provider = model_info[1]
+    
+    print(f"🤖 Usando modelo: {modelo} ({provider.upper()})")
+    
+    resposta = api_client.query_model(modelo, model_info, messages)
+    
+    # Adiciona informação do modelo usado na resposta
+    resposta_final = f"{resposta}\n\n---\n*Resposta gerada por: {modelo} ({provider.upper()})*"
+    
+    add_to_memory(session_id, pergunta, resposta_final)
+    return resposta_final
+
+def listar_modelos_disponiveis() -> str:
+    """Retorna uma lista formatada dos modelos disponíveis."""
+    if not MODELS:
+        return "❌ Nenhum modelo está disponível no momento."
+    
+    resultado = "🤖 **MODELOS DISPONÍVEIS:**\n\n"
+    
+    # Organiza por provedor
+    providers = {}
+    for label, (model_name, provider) in MODELS.items():
+        if provider not in providers:
+            providers[provider] = []
+        providers[provider].append(label)
+    
+    for provider, models in providers.items():
+        resultado += f"**{provider.upper()}:**\n"
+        for i, model in enumerate(models, 1):
+            resultado += f"   {i}. {model}\n"
+        resultado += "\n"
+    
+    return resultado
 
 # --- Inicialização ---
 def inicializar_sistema():
     """
-    Inicializa o sistema, garantindo no mínimo 3 modelos disponíveis.
-    Retorna uma tupla: (status: bool, models: dict)
-    - status: True se >= 3 modelos disponíveis, False caso contrário
-    - models: Dicionário com os modelos disponíveis
+    Inicializa o sistema, testando todos os modelos disponíveis.
+    Retorna uma tupla: (status: bool, models: dict, message: str)
     """
-    print("Inicializando Chatbot Dr. Aldo...")
+    print("🚀 Inicializando Chatbot Dr. Aldo com Fallback para Modelos Gratuitos...")
     
     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!")
-        return True, MODELS
+        message = f"✅ Sistema inicializado com {num_available_models} modelo(s) disponível(is)!"
+        print(message)
+        return True, MODELS, message
     else:
-        print(f"Erro: Apenas {num_available_models} modelos disponíveis. São necessários pelo menos 3 modelos para iniciar o sistema.")
-        return False, MODELS
+        message = "❌ Nenhum modelo disponível. Verifique as configurações das APIs."
+        print(message)
+        return False, MODELS, message
 
+# --- Exemplo de uso ---
 if __name__ == "__main__":
-    status, models = inicializar_sistema()
+    # Configuração de exemplo das APIs (coloque suas chaves aqui)
+    print("🔧 Configuração das APIs:")
+    print(f"   HuggingFace: {'✅ Configurado' if HF_TOKEN else '❌ Não configurado'}")
+    print(f"   Groq: {'✅ Configurado' if GROQ_API_KEY else '❌ Não configurado'}")
+    print(f"   Gemini: {'✅ Configurado' if GEMINI_API_KEY else '❌ Não configurado'}")
+    print()
+    
+    # Inicializa o sistema
+    status, models, message = inicializar_sistema()
+    
     if status:
-        print("\n" + "="*50)
-        print("SISTEMA INICIADO: Realizando teste básico do Chatbot... ")
-        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("\n" + "="*70)
+        print("🧪 REALIZANDO TESTE BÁSICO DO CHATBOT...")
+        print("="*70)
+        
+        # Lista modelos disponíveis
+        print(listar_modelos_disponiveis())
+        
+        # Testa com diferentes modelos
+        session_id = "teste_demo"
+        
+        # Primeira pergunta
+        print("👤 PERGUNTA 1: O que é Java?")
+        print("🤖 RESPOSTA:")
+        resposta1 = responder_como_aldo(session_id, "O que é Java?")
+        print(resposta1)
+        
+        print("\n" + "-"*70)
+        
+        # Segunda pergunta
+        print("👤 PERGUNTA 2: Mostre um exemplo de código Java simples.")
+        print("🤖 RESPOSTA:")
+        resposta2 = responder_como_aldo(session_id, "Mostre um exemplo de código Java simples.")
+        print(resposta2)
+        
+        print("\n" + "-"*70)
+        
+        # Terceira pergunta para testar contexto
+        print("👤 PERGUNTA 3: Explique melhor o conceito de classe no exemplo anterior.")
+        print("🤖 RESPOSTA:")
+        resposta3 = responder_como_aldo(session_id, "Explique melhor o conceito de classe no exemplo anterior.")
+        print(resposta3)
+        
+        print("\n" + "-"*70)
+        print("🧹 LIMPANDO MEMÓRIA DE TESTE...")
         print(clear_memory(session_id))
+        print("="*70)
+        
+    else:
+        print(f"\n❌ {message}")
+        print("\n💡 DICAS PARA RESOLVER:")
+        print("1. Configure pelo menos uma das APIs:")
+        print("   - HuggingFace: export HF_TOKEN='seu_token_aqui'")
+        print("   - Groq: export GROQ_API_KEY='sua_chave_aqui'")
+        print("   - Gemini: export GEMINI_API_KEY='sua_chave_aqui'")
+        print("\n2. APIs gratuitas recomendadas:")
+        print("   - Groq: https://console.groq.com/ (gratuito)")
+        print("   - Google AI Studio: https://aistudio.google.com/ (gratuito)")
+        print("   - HuggingFace: https://huggingface.co/settings/tokens (gratuito)")
+
+
+# --- Funções Auxiliares para Integração ---
+
+def criar_interface_gradio():
+    """Cria interface Gradio para o chatbot (opcional)."""
+    try:
+        import gradio as gr
+        
+        def chat_interface(message, history, model_choice):
+            """Interface do chat para Gradio."""
+            session_id = "gradio_session"
+            
+            if not message.strip():
+                return "", history
+            
+            # Seleciona modelo se especificado
+            modelo_selecionado = model_choice if model_choice in MODELS else None
+            
+            # Gera resposta
+            resposta = responder_como_aldo(session_id, message, modelo_selecionado)
+            
+            # Atualiza histórico
+            history.append((message, resposta))
+            
+            return "", history
+        
+        def listar_modelos():
+            """Lista modelos para dropdown."""
+            return list(MODELS.keys()) if MODELS else ["Nenhum modelo disponível"]
+        
+        # Cria interface
+        with gr.Blocks(title="Dr. Aldo Henrique - Chatbot Educacional") as demo:
+            gr.Markdown("# 🤖 Dr. Aldo Henrique - Chatbot Educacional")
+            gr.Markdown("Assistente especializado em Ciência da Computação, IA e Programação")
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    chatbot = gr.Chatbot(
+                        label="Conversa",
+                        height=500,
+                        show_label=True
+                    )
+                    
+                    with gr.Row():
+                        msg = gr.Textbox(
+                            label="Sua pergunta",
+                            placeholder="Digite sua pergunta sobre tecnologia...",
+                            lines=2,
+                            scale=4
+                        )
+                        send_btn = gr.Button("Enviar", scale=1)
+                
+                with gr.Column(scale=1):
+                    model_dropdown = gr.Dropdown(
+                        choices=listar_modelos(),
+                        label="Modelo",
+                        value=list(MODELS.keys())[0] if MODELS else None,
+                        interactive=True
+                    )
+                    
+                    gr.Markdown("### 📊 Modelos Disponíveis")
+                    model_info = gr.Markdown(listar_modelos_disponiveis())
+                    
+                    refresh_btn = gr.Button("🔄 Atualizar Modelos")
+                    clear_btn = gr.Button("🧹 Limpar Conversa")
+            
+            # Eventos
+            send_btn.click(
+                chat_interface,
+                inputs=[msg, chatbot, model_dropdown],
+                outputs=[msg, chatbot]
+            )
+            
+            msg.submit(
+                chat_interface,
+                inputs=[msg, chatbot, model_dropdown],
+                outputs=[msg, chatbot]
+            )
+            
+            def refresh_models():
+                test_and_update_models()
+                return gr.Dropdown(choices=listar_modelos()), listar_modelos_disponiveis()
+            
+            refresh_btn.click(
+                refresh_models,
+                outputs=[model_dropdown, model_info]
+            )
+            
+            def clear_chat():
+                clear_memory("gradio_session")
+                return []
+            
+            clear_btn.click(clear_chat, outputs=[chatbot])
+        
+        return demo
+        
+    except ImportError:
+        print("⚠️  Gradio não está instalado. Para usar a interface web, instale com:")
+        print("   pip install gradio")
+        return None
+
+def criar_interface_streamlit():
+    """Cria interface Streamlit para o chatbot (opcional)."""
+    try:
+        import streamlit as st
+        
+        def main():
+            st.title("🤖 Dr. Aldo Henrique - Chatbot Educacional")
+            st.markdown("Assistente especializado em Ciência da Computação, IA e Programação")
+            
+            # Sidebar com informações
+            with st.sidebar:
+                st.header("🔧 Configurações")
+                
+                # Seleção de modelo
+                if MODELS:
+                    modelo_selecionado = st.selectbox(
+                        "Selecione o modelo:",
+                        options=list(MODELS.keys()),
+                        index=0
+                    )
+                else:
+                    st.error("Nenhum modelo disponível")
+                    return
+                
+                # Botão para atualizar modelos
+                if st.button("🔄 Atualizar Modelos"):
+                    with st.spinner("Testando modelos..."):
+                        test_and_update_models()
+                    st.success("Modelos atualizados!")
+                    st.rerun()
+                
+                # Informações dos modelos
+                st.markdown("### 📊 Modelos Disponíveis")
+                st.markdown(listar_modelos_disponiveis())
+                
+                # Limpar conversa
+                if st.button("🧹 Limpar Conversa"):
+                    clear_memory("streamlit_session")
+                    if "messages" in st.session_state:
+                        del st.session_state.messages
+                    st.success("Conversa limpa!")
+                    st.rerun()
+            
+            # Inicializar mensagens
+            if "messages" not in st.session_state:
+                st.session_state.messages = []
+            
+            # Exibir mensagens
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+            
+            # Input do usuário
+            if prompt := st.chat_input("Digite sua pergunta sobre tecnologia..."):
+                # Adicionar mensagem do usuário
+                st.session_state.messages.append({"role": "user", "content": prompt})
+                with st.chat_message("user"):
+                    st.markdown(prompt)
+                
+                # Gerar resposta
+                with st.chat_message("assistant"):
+                    with st.spinner("Pensando..."):
+                        resposta = responder_como_aldo("streamlit_session", prompt, modelo_selecionado)
+                    st.markdown(resposta)
+                
+                # Adicionar resposta do assistente
+                st.session_state.messages.append({"role": "assistant", "content": resposta})
+        
+        return main
+        
+    except ImportError:
+        print("⚠️  Streamlit não está instalado. Para usar a interface web, instale com:")
+        print("   pip install streamlit")
+        return None
+
+def executar_interface_web(tipo="gradio"):
+    """Executa interface web do chatbot."""
+    print(f"🌐 Iniciando interface web ({tipo})...")
+    
+    # Inicializa sistema
+    status, models, message = inicializar_sistema()
+    
+    if not status:
+        print(f"❌ Não foi possível inicializar: {message}")
+        return
+    
+    if tipo.lower() == "gradio":
+        demo = criar_interface_gradio()
+        if demo:
+            demo.launch(
+                server_name="0.0.0.0",
+                server_port=7860,
+                share=True,
+                debug=True
+            )
+    elif tipo.lower() == "streamlit":
+        main_func = criar_interface_streamlit()
+        if main_func:
+            print("Execute com: streamlit run nome_do_arquivo.py")
+            return main_func
     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("❌ Tipo de interface não suportado. Use 'gradio' ou 'streamlit'")
+
+# --- Função para Instalar Dependências ---
+def instalar_dependencias():
+    """Instala dependências necessárias para o sistema."""
+    import subprocess
+    import sys
+    
+    dependencias = [
+        "requests",
+        "beautifulsoup4",
+        "langchain",
+        "langchain-community",
+        "faiss-cpu",
+        "sentence-transformers",
+        "groq",
+        "google-generativeai",
+        "gradio",
+        "streamlit"
+    ]
+    
+    print("📦 Instalando dependências...")
+    for dep in dependencias:
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", dep])
+            print(f"✅ {dep} instalado com sucesso")
+        except subprocess.CalledProcessError:
+            print(f"❌ Erro ao instalar {dep}")
+
+# --- Instruções de Uso ---
+def mostrar_instrucoes():
+    """Mostra instruções de uso do sistema."""
+    print("""
+🚀 INSTRUÇÕES DE USO - Dr. Aldo Henrique Chatbot
+
+1. 🔑 CONFIGURAÇÃO DAS APIs:
+   Configure pelo menos uma das variáveis de ambiente:
+   
+   export HF_TOKEN="seu_token_huggingface"
+   export GROQ_API_KEY="sua_chave_groq"  
+   export GEMINI_API_KEY="sua_chave_gemini"
+
+2. 🆓 APIS GRATUITAS RECOMENDADAS:
+   
+   • Groq (Recomendado): https://console.groq.com/
+     - Modelos: Llama 3, Mixtral, Gemma
+     - Rate limit: 30 req/min (gratuito)
+   
+   • Google AI Studio: https://aistudio.google.com/
+     - Modelos: Gemini 1.5 Flash/Pro
+     - Rate limit: 15 req/min (gratuito)
+   
+   • HuggingFace: https://huggingface.co/settings/tokens
+     - Modelos: Diversos modelos open source
+     - Rate limit: Variável por modelo
+
+3. 📚 EXEMPLOS DE USO:
+   
+   # Uso básico
+   python nome_do_arquivo.py
+   
+   # Interface web Gradio
+   executar_interface_web("gradio")
+   
+   # Interface web Streamlit  
+   executar_interface_web("streamlit")
+
+4. 🎯 FUNCIONALIDADES:
+   
+   • Chat inteligente com memória de conversa
+   • Múltiplos modelos de IA como fallback
+   • RAG (busca no blog do Dr. Aldo)
+   • Perfil adaptativo do usuário
+   • Respostas educacionais personalizadas
+
+5. 🔧 SOLUÇÃO DE PROBLEMAS:
+   
+   • Sem modelos disponíveis: Verifique as chaves das APIs
+   • Erro de token: Regenere as chaves nas respectivas plataformas
+   • Rate limit: Aguarde alguns minutos entre as requisições
+   • Erro de dependência: Execute instalar_dependencias()
+
+6. 📞 SUPORTE:
+   
+   Para dúvidas técnicas sobre o código, consulte:
+   • Blog: https://aldohenrique.com.br/
+   • Documentação das APIs utilizadas
+   
+""")
+
+# Executar instruções se chamado diretamente
+if __name__ == "__main__":
+    mostrar_instrucoes()