Update ai_logic.py

ai_logic.py

@@ -15,34 +15,173 @@ from langchain.embeddings import HuggingFaceEmbeddings
 BLOG_URL = "https://aldohenrique.com.br/"
 VECTOR_STORE_PATH = "faiss_index_store.pkl"
 PROCESSED_URLS_PATH = "processed_urls.pkl"
+CONVERSATION_MEMORY_PATH = "conversation_memory.json"  # Novo arquivo para memória
 
 # --- Configuração da API Hugging Face ---
 HF_TOKEN = os.getenv("HF_TOKEN")
 if not HF_TOKEN:
     raise ValueError("Token HF_TOKEN não encontrado nas variáveis de ambiente")
 
-MODELS = {
-    "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
-    "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta",
-    "Gemma 2B (Google)": "google/gemma-2b-it",
-    "Open Hermes 2.5 (teknium)": "teknium/OpenHermes-2.5-Mistral-7B",
-    "TinyLlama 1.1B (TinyLlama Project)": "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
-}
 MODELS = {
     "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
     "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
     "Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta"
 }
 
-
 DEFAULT_MODEL = "Phi-3 Mini (Microsoft)"
 
-# --- Variáveis Globais para o RAG ---
+# --- Variáveis Globais para o RAG e Memória ---
 vector_store: Optional[FAISS] = None
+conversation_memory: List[Dict[str, str]] = []  # Memória da conversa atual
+max_memory_length = 10  # Máximo de trocas de mensagens na memória
+user_profile = {}  # Perfil do usuário (interesses, nível de conhecimento, etc.)
 
 # ==============================================================================
-# SEÇÃO RAG: FUNÇÕES PARA CRAWLING, EMBEDDING E ARMAZENAMENTO
+# SEÇÃO MEMÓRIA: GERENCIAMENTO DA CONVERSA E PERFIL DO USUÁRIO
+# ==============================================================================
+
+def load_conversation_memory():
+    """Carrega a memória da conversa do arquivo JSON."""
+    global conversation_memory, user_profile
+    try:
+        if os.path.exists(CONVERSATION_MEMORY_PATH):
+            with open(CONVERSATION_MEMORY_PATH, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                conversation_memory = data.get('conversation', [])
+                user_profile = data.get('user_profile', {})
+            print(f"Memória carregada: {len(conversation_memory)} mensagens")
+        else:
+            conversation_memory = []
+            user_profile = {}
+            print("Nova conversa iniciada")
+    except Exception as e:
+        print(f"Erro ao carregar memória: {e}")
+        conversation_memory = []
+        user_profile = {}
+
+def save_conversation_memory():
+    """Salva a memória da conversa no arquivo JSON."""
+    try:
+        data = {
+            'conversation': conversation_memory,
+            'user_profile': user_profile,
+            'last_updated': time.time()
+        }
+        with open(CONVERSATION_MEMORY_PATH, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    except Exception as e:
+        print(f"Erro ao salvar memória: {e}")
+
+def add_to_memory(user_message: str, assistant_response: str):
+    """Adiciona uma troca de mensagens à memória."""
+    global conversation_memory
+    
+    conversation_memory.append({
+        "role": "user",
+        "content": user_message,
+        "timestamp": time.time()
+    })
+    
+    conversation_memory.append({
+        "role": "assistant", 
+        "content": assistant_response,
+        "timestamp": time.time()
+    })
+    
+    # Limita o tamanho da memória
+    if len(conversation_memory) > max_memory_length * 2:  # *2 porque temos user + assistant
+        conversation_memory = conversation_memory[-max_memory_length * 2:]
+    
+    save_conversation_memory()
+
+def update_user_profile(user_message: str):
+    """Atualiza o perfil do usuário baseado nas mensagens."""
+    global user_profile
+    
+    # Detecta tópicos de interesse
+    topics = {
+        'java': ['java', 'classe', 'objeto', 'herança', 'polimorfismo'],
+        'c': ['linguagem c', 'ponteiro', 'malloc', 'struct'],
+        'web': ['html', 'css', 'javascript', 'react', 'node'],
+        'ia': ['inteligência artificial', 'machine learning', 'neural', 'algoritmo'],
+        'banco_dados': ['sql', 'database', 'banco de dados', 'mysql']
+    }
+    
+    user_message_lower = user_message.lower()
+    
+    for topic, keywords in topics.items():
+        if any(keyword in user_message_lower for keyword in keywords):
+            user_profile[f'interesse_{topic}'] = user_profile.get(f'interesse_{topic}', 0) + 1
+    
+    # Detecta nível de conhecimento baseado na complexidade das perguntas
+    if any(word in user_message_lower for word in ['básico', 'iniciante', 'começar', 'o que é']):
+        user_profile['nivel'] = 'iniciante'
+    elif any(word in user_message_lower for word in ['avançado', 'complexo', 'otimização', 'performance']):
+        user_profile['nivel'] = 'avançado'
+    elif user_profile.get('nivel') is None:
+        user_profile['nivel'] = 'intermediario'
+    
+    user_profile['total_perguntas'] = user_profile.get('total_perguntas', 0) + 1
+
+def get_conversation_context() -> str:
+    """Gera um resumo do contexto da conversa para o prompt."""
+    if not conversation_memory:
+        return ""
+    
+    # Pega as últimas 6 mensagens (3 trocas)
+    recent_messages = conversation_memory[-6:] if len(conversation_memory) > 6 else conversation_memory
+    
+    context = "--- CONTEXTO DA CONVERSA ANTERIOR ---\n"
+    for msg in recent_messages:
+        role = "USUÁRIO" if msg["role"] == "user" else "PROFESSOR"
+        # Limita o tamanho de cada mensagem no contexto
+        content = msg["content"][:200] + "..." if len(msg["content"]) > 200 else msg["content"]
+        context += f"{role}: {content}\n"
+    
+    context += "--- FIM DO CONTEXTO DA CONVERSA ---\n"
+    return context
+
+def get_user_profile_context() -> str:
+    """Gera informações sobre o perfil do usuário para personalizar a resposta."""
+    if not user_profile:
+        return ""
+    
+    context = "--- PERFIL DO ALUNO ---\n"
+    
+    # Nível de conhecimento
+    nivel = user_profile.get('nivel', 'intermediario')
+    context += f"Nível: {nivel}\n"
+    
+    # Principais interesses
+    interesses = []
+    for key, value in user_profile.items():
+        if key.startswith('interesse_') and value > 0:
+            topic = key.replace('interesse_', '').replace('_', ' ')
+            interesses.append(f"{topic} ({value}x)")
+    
+    if interesses:
+        context += f"Principais interesses: {', '.join(interesses)}\n"
+    
+    total = user_profile.get('total_perguntas', 0)
+    context += f"Total de perguntas feitas: {total}\n"
+    context += "--- FIM DO PERFIL DO ALUNO ---\n"
+    
+    return context
+
+def clear_memory():
+    """Limpa a memória da conversa (função útil para resetar o chat)."""
+    global conversation_memory, user_profile
+    conversation_memory = []
+    user_profile = {}
+    try:
+        if os.path.exists(CONVERSATION_MEMORY_PATH):
+            os.remove(CONVERSATION_MEMORY_PATH)
+        return "✅ Memória da conversa limpa com sucesso!"
+    except Exception as e:
+        return f"❌ Erro ao limpar memória: {e}"
+
+# ==============================================================================
+# SEÇÃO RAG: FUNÇÕES PARA CRAWLING, EMBEDDING E ARMAZENAMENTO (SEM ALTERAÇÕES)
 # ==============================================================================
 
 def get_all_blog_links(url: str, processed_urls: set) -> set:
@@ -65,13 +204,11 @@ def get_all_blog_links(url: str, processed_urls: set) -> set:
             for link in soup.find_all('a', href=True):
                 href = link['href']
                 full_url = urljoin(url, href)
-                # Garante que estamos no mesmo domínio e não é um link de âncora
                 if urlparse(full_url).netloc == urlparse(url).netloc and full_url not in visited_links:
                     links_to_visit.add(full_url)
         except requests.RequestException as e:
             print(f"Erro ao acessar {current_url}: {e}")
 
-    # Filtra apenas as páginas que parecem ser posts ou páginas de conteúdo
     final_links = {link for link in visited_links if '/tag/' not in link and '/category/' not in link and '?' not in link}
     return final_links
 
@@ -80,7 +217,6 @@ def scrape_text_from_url(url: str) -> str:
     try:
         response = requests.get(url, timeout=10)
         soup = BeautifulSoup(response.content, 'html.parser')
-        # Tenta encontrar a tag <article> ou <main> que geralmente contém o conteúdo principal
         main_content = soup.find('article') or soup.find('main')
         if main_content:
             return main_content.get_text(separator='\n', strip=True)
@@ -92,8 +228,6 @@ def scrape_text_from_url(url: str) -> str:
 def build_and_save_vector_store() -> Tuple[str, Optional[str], Optional[str]]:
     """
     Função principal do RAG: raspa o blog, cria chunks, gera embeddings e salva o vector store.
-    Esta é a nossa função de "treino".
-    Retorna uma tupla (mensagem_status, caminho_do_arquivo_faiss_para_download, caminho_do_arquivo_urls_para_download).
     """
     global vector_store
     start_time = time.time()
@@ -101,31 +235,26 @@ def build_and_save_vector_store() -> Tuple[str, Optional[str], Optional[str]]:
     print("Iniciando o processo de retreino do RAG...")
     processed_urls = set()
 
-    # 1. Obter todos os links do blog
     all_links = get_all_blog_links(BLOG_URL, processed_urls)
     print(f"Encontrados {len(all_links)} links para processar.")
 
-    # 2. Raspar o texto de cada link
     all_texts = [scrape_text_from_url(link) for link in all_links if link not in processed_urls]
-    all_texts = [text for text in all_texts if text] # Remove textos vazios
+    all_texts = [text for text in all_texts if text]
     print(f"Textos extraídos de {len(all_texts)} novas páginas.")
 
     if not all_texts:
-        return "Nenhum novo conteúdo encontrado para treinar.", None, None # Retorna None para os arquivos se não houver conteúdo
+        return "Nenhum novo conteúdo encontrado para treinar.", None, None
 
-    # 3. Dividir os textos em chunks
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
     chunks = text_splitter.create_documents(all_texts)
     print(f"Textos divididos em {len(chunks)} chunks.")
 
-    # 4. Criar embeddings e o vector store (FAISS)
     print("Carregando modelo de embedding...")
     embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
     print("Criando o vector store com FAISS...")
     vector_store = FAISS.from_documents(chunks, embeddings_model)
 
-    # 5. Salvar o vector store e as URLs processadas em disco
     with open(VECTOR_STORE_PATH, "wb") as f:
         pickle.dump(vector_store, f)
 
@@ -146,10 +275,8 @@ def load_vector_store():
         print("Vector store carregado com sucesso.")
     else:
         print("Nenhum vector store encontrado. É necessário treinar o modelo.")
-        # Inicia o treino automaticamente se não houver um índice
-        # Modificado para ignorar o retorno dos caminhos dos arquivos ao carregar
         message, _, _ = build_and_save_vector_store()
-        print(message) # Imprime a mensagem de status do treino inicial
+        print(message)
 
 def retrieve_context_from_blog(query: str, k: int = 3) -> str:
     """Busca no vector store por chunks de texto similares à pergunta."""
@@ -242,14 +369,13 @@ class HuggingFaceAPIClient:
 api_client = HuggingFaceAPIClient(HF_TOKEN)
 
 # ==============================================================================
-# SEÇÃO PRINCIPAL: LÓGICA DO CHATBOT
+# SEÇÃO PRINCIPAL: LÓGICA DO CHATBOT COM MEMÓRIA
 # ==============================================================================
 
 def formatar_resposta_com_codigo(resposta: str) -> str:
     """Formata a resposta destacando códigos em blocos separados."""
     if not resposta: return resposta
     
-    # Primeiro, substituir < e > por entidades HTML para evitar interpretação como tags
     resposta = resposta.replace('<', '&lt;').replace('>', '&gt;')    
     resposta_formatada = re.sub(
         r'```(\w+)?\n(.*?)\n```',
@@ -270,44 +396,72 @@ def formatar_resposta_com_codigo(resposta: str) -> str:
     return resposta_formatada
 
 def responder_como_aldo(pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) -> str:
-    """Função principal para gerar respostas, agora com RAG."""
+    """Função principal para gerar respostas, agora com RAG e MEMÓRIA."""
     if not pergunta.strip():
         return "Por favor, faça uma pergunta."
 
     try:
+        # Atualiza o perfil do usuário baseado na pergunta
+        update_user_profile(pergunta)
+        
         # --- ETAPA DE RAG ---
         print(f"Buscando contexto para a pergunta: '{pergunta[:50]}...'")
         contexto_blog = retrieve_context_from_blog(pergunta)
         
-        # Montar o prompt do sistema com o contexto do RAG
-        system_prompt = (
-            "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. "
-            "Responda com clareza, profundidade e tom acadêmico. Foque em explicar e não em só mostrar o resultado. "
-            "Responda sempre em português brasileiro. Use blocos de código formatados com ```. "
-            "Não responda se a pergunta não for sobre o universo de programação e tecnologia."
-            "Nem sempre fornecer código, mas quando tiver código, sempre explique utilizando comentários, o aluno precisa aprender lendo os comentários."
-            "Quando for pergunta sobre disciplinas, foque no conteúdo do blog."
-        )
+        # --- ETAPA DE MEMÓRIA ---
+        contexto_conversa = get_conversation_context()
+        contexto_perfil = get_user_profile_context()
+        
+        # Prompt do sistema personalizado baseado no perfil do usuário
+        nivel = user_profile.get('nivel', 'intermediario')
+        
+        system_prompt = f"""Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial.
+
+PERSONALIDADE E COMPORTAMENTO:
+- Seja caloroso, acolhedor e paciente como um professor humano experiente
+- Demonstre interesse genuíno pelo aprendizado do aluno
+- Use um tom conversacional e amigável, mas mantenha autoridade acadêmica
+- Quando apropriado, faça conexões com conversas anteriores
+- Celebre o progresso do aluno e encoraje quando necessário
+- Adapte sua linguagem ao nível do aluno: {nivel}
+
+ESTILO DE ENSINO:
+- Sempre explique o "porquê" antes do "como"
+- Use analogias e exemplos práticos
+- Encoraje perguntas e curiosidade
+- Quando mostrar código, sempre explique com comentários detalhados
+- Foque na compreensão, não apenas na solução
+- Conecte conceitos com aplicações do mundo real
+
+REGRAS:
+- Responda sempre em português brasileiro
+- Use blocos de código formatados com ```
+- Só responda perguntas relacionadas a programação e tecnologia
+- Se não for sobre TI, informe educadamente que sua especialidade é tecnologia
+- Quando apresentar código, sempre explique linha por linha nos comentários"""
+
+        # Monta o prompt completo com todos os contextos
+        prompt_parts = []
         
-        # Montar prompt do usuário, injetando o contexto do blog
+        if contexto_perfil:
+            prompt_parts.append(contexto_perfil)
+        
+        if contexto_conversa:
+            prompt_parts.append(contexto_conversa)
+            
         if contexto_blog:
-            pergunta_completa = (
-                "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. "
-                "Com base no seguinte contexto extraído do seu blog, responda à pergunta do usuário.\n\n"
-                "--- CONTEXTO DO BLOG ---\n"
-                f"{contexto_blog}\n"
-                "--- FIM DO CONTEXTO ---\n\n"
-                f"PERGUNTA DO USUÁRIO: {pergunta}"
-            "Responda sempre em português brasileiro. Use blocos de código formatados com ```. "
-            "Não responda nada se a pergunta não for sobre o universo de programação e tecnologia."
-            "Nem sempre fornecer código, mas quando tiver código, sempre explique utilizando comentários, o aluno precisa aprender lendo os comentários."
-            "Quando for pergunta sobre disciplinas, foque no conteúdo do blog."
-            )
-            print("Contexto encontrado e injetado no prompt.")
-        else:
-            pergunta_completa = f"{pergunta} Não responda nada se a pergunta não for sobre o universo de programação e tecnologia, informe que o Dr. Aldo Henrique só tem domínio em TI. Você é o Professor Dr. Aldo Henrique, foque em explicar e não em só mostrar o resultado. Quando apresentar código, use blocos de código formatados com ```. Sempre responda primeiro a explicação e depois modestre o código."
-            print("Nenhum contexto relevante encontrado no blog, usando prompt padrão.")
-
+            prompt_parts.append("--- CONTEXTO DO SEU BLOG ---")
+            prompt_parts.append(contexto_blog)
+            prompt_parts.append("--- FIM DO CONTEXTO DO BLOG ---")
+        
+        prompt_parts.append(f"PERGUNTA ATUAL DO ALUNO: {pergunta}")
+        
+        # Adiciona instruções específicas baseadas no contexto
+        if contexto_conversa:
+            prompt_parts.append("\nIMPORTANTE: Considere o contexto da nossa conversa anterior ao responder. Se esta pergunta se relaciona com algo que já discutimos, faça essa conexão naturalmente.")
+        
+        pergunta_completa = "\n\n".join(prompt_parts)
+        
         messages = [
             {"role": "system", "content": system_prompt},
             {"role": "user", "content": pergunta_completa}
@@ -318,14 +472,20 @@ def responder_como_aldo(pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) ->
         
         if resposta.startswith("Assistente: "):
             resposta = resposta.replace("Assistente: ", "")
-            
+        
+        # Adiciona a conversa à memória
+        add_to_memory(pergunta, resposta)
+        
         resposta_formatada = formatar_resposta_com_codigo(resposta.strip())
         return resposta_formatada
         
     except Exception as e:
         return f"Erro ao processar sua pergunta: {str(e)}"
 
-# Funções de teste
+# ==============================================================================
+# FUNÇÕES AUXILIARES E DE TESTE
+# ==============================================================================
+
 def verificar_modelo_disponivel(model_name: str) -> str:
     try:
         url = f"https://api-inference.huggingface.co/models/{model_name}"
@@ -344,4 +504,48 @@ def testar_todos_modelos():
     for nome, modelo in MODELS.items():
         status = verificar_modelo_disponivel(modelo)
         resultados.append(f"{nome}: {status}")
-    return "\n".join(resultados)
+    return "\n".join(resultados)
+
+def get_memory_stats() -> str:
+    """Retorna estatísticas da memória atual."""
+    total_messages = len(conversation_memory)
+    user_messages = len([m for m in conversation_memory if m["role"] == "user"])
+    
+    stats = f"📊 **Estatísticas da Memória:**\n"
+    stats += f"• Total de mensagens: {total_messages}\n"
+    stats += f"• Perguntas do usuário: {user_messages}\n"
+    stats += f"• Nível detectado: {user_profile.get('nivel', 'Não definido')}\n"
+    
+    # Principais interesses
+    interesses = []
+    for key, value in user_profile.items():
+        if key.startswith('interesse_') and value > 0:
+            topic = key.replace('interesse_', '').replace('_', ' ').title()
+            interesses.append(f"{topic} ({value})")
+    
+    if interesses:
+        stats += f"• Principais interesses: {', '.join(interesses)}\n"
+    
+    return stats
+
+# ==============================================================================
+# INICIALIZAÇÃO DO SISTEMA
+# ==============================================================================
+
+def inicializar_sistema():
+    """Inicializa todos os componentes do sistema."""
+    print("🚀 Inicializando o Chatbot Dr. Aldo Henrique com Memória...")
+    
+    # Carrega o vector store (RAG)
+    load_vector_store()
+    
+    # Carrega a memória de conversas
+    load_conversation_memory()
+    
+    print("✅ Sistema inicializado com sucesso!")
+    print(f"💬 Memória: {len(conversation_memory)} mensagens carregadas")
+    print(f"🧠 Vector Store: {'Carregado' if vector_store else 'Não encontrado'}")
+
+# Chama a inicialização quando o módulo é carregado
+if __name__ == "__main__":
+    inicializar_sistema()