Update ai_logic.py

ai_logic.py

@@ -46,7 +46,7 @@ DEFAULT_MODEL = "Llama 3.2 3B"
 
 # --- Gerenciamento de Sessão ---
 user_sessions: Dict[str, Dict[str, List | Dict]] = {}
-MAX_MEMORY_LENGTH = 5
+MAX_MEMORY_LENGTH = 8  # Aumentado para ter mais contexto útil
 
 def get_session_memory_path(session_id: str) -> str:
     """Retorna o caminho do arquivo de memória para a sessão."""
@@ -85,6 +85,7 @@ def add_to_memory(session_id: str, user_message: str, assistant_response: str):
         {"role": "user", "content": user_message, "timestamp": time.time()},
         {"role": "assistant", "content": assistant_response, "timestamp": time.time()}
     ])
+    # Mantém apenas as últimas conversas para evitar contexto muito longo
     if len(conversation) > MAX_MEMORY_LENGTH * 2:
         user_sessions[session_id]['conversation'] = conversation[-MAX_MEMORY_LENGTH * 2:]
     save_conversation_memory(session_id)
@@ -112,24 +113,54 @@ def update_user_profile(session_id: str, user_message: str):
     profile['total_perguntas'] = profile.get('total_perguntas', 0) + 1
     user_sessions[session_id]['user_profile'] = profile
 
-def get_conversation_context(session_id: str) -> str:
-    """Gera o contexto da conversa recente."""
+def get_conversation_messages(session_id: str) -> List[Dict]:
+    """
+    NOVA FUNÇÃO: Retorna as mensagens da conversa em formato adequado para o modelo.
+    Esta é a chave para resolver o problema de duplicação!
+    """
     load_conversation_memory(session_id)
-    conversation = user_sessions[session_id]['conversation'][-4:]
-    if not conversation:
-        return ""
-    return "\n".join(f"{msg['role'].upper()}: {msg['content']}" for msg in conversation)
+    conversation = user_sessions[session_id]['conversation']
+    
+    # Pega apenas as últimas 6 mensagens (3 trocas) para não sobrecarregar
+    recent_conversation = conversation[-6:] if len(conversation) > 6 else conversation
+    
+    # Converte para formato de mensagens do modelo
+    messages = []
+    for msg in recent_conversation:
+        # Remove metadados desnecessários das mensagens antigas
+        clean_content = msg['content']
+        
+        # Remove a linha de informação do modelo das respostas antigas
+        if msg['role'] == 'assistant' and '*Resposta gerada pelo modelo:' in clean_content:
+            clean_content = clean_content.split('*Resposta gerada pelo modelo:')[0].strip()
+        
+        messages.append({
+            "role": msg['role'],
+            "content": clean_content
+        })
+    
+    return messages
 
 def get_user_profile_context(session_id: str) -> str:
-    """Gera o contexto do perfil do usuário."""
+    """Gera o contexto do perfil do usuário de forma mais concisa."""
     load_conversation_memory(session_id)
     profile = user_sessions[session_id]['user_profile']
-    context = f"Nível: {profile.get('nivel', 'intermediario')}\n"
-    context += f"Total de perguntas: {profile.get('total_perguntas', 0)}\n"
-    interesses = [f"{k.replace('interesse_', '').title()} ({v})" for k, v in profile.items() if k.startswith('interesse_')]
+    
+    # Contexto mais conciso para não poluir o prompt
+    nivel = profile.get('nivel', 'intermediario')
+    total = profile.get('total_perguntas', 0)
+    
+    context_parts = [f"Nível: {nivel}"]
+    
+    # Só inclui interesses se há algum padrão significativo
+    interesses = [k.replace('interesse_', '').title() 
+                  for k, v in profile.items() 
+                  if k.startswith('interesse_') and v >= 2]  # Só se perguntou pelo menos 2 vezes
+    
     if interesses:
-        context += f"Interesses: {', '.join(interesses)}\n"
-    return context
+        context_parts.append(f"Interesses: {', '.join(interesses)}")
+    
+    return " | ".join(context_parts)
 
 def clear_memory(session_id: str) -> str:
     """Limpa a memória de uma sessão específica."""
@@ -216,12 +247,23 @@ def load_vector_store():
         print("Tentando criar novo vector store...")
         build_and_save_vector_store()
 
-def retrieve_context_from_blog(query: str, k: int = 4) -> str:
-    """Busca contexto relevante no vector store."""
+def retrieve_context_from_blog(query: str, k: int = 3) -> str:
+    """Busca contexto relevante no vector store - Reduzido para evitar sobrecarga."""
     if vector_store:
         try:
             results = vector_store.similarity_search(query, k=k)
-            return "\n".join(doc.page_content for doc in results)
+            # Limita o tamanho do contexto para evitar tokens excessivos
+            context_parts = []
+            total_chars = 0
+            max_chars = 1500  # Limite de caracteres do contexto do blog
+            
+            for doc in results:
+                if total_chars + len(doc.page_content) > max_chars:
+                    break
+                context_parts.append(doc.page_content)
+                total_chars += len(doc.page_content)
+            
+            return "\n---\n".join(context_parts)
         except Exception as e:
             print(f"Erro ao buscar contexto: {e}")
     return ""
@@ -277,8 +319,8 @@ class HuggingFaceInferenceClient:
             else:
                 return False, f"Erro: {str(e)[:100]}"
 
-    def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 2000, temperature: float = 0.5) -> str:
-        """Faz requisição ao modelo usando chat completion."""
+    def query_model(self, model_name: str, messages: List[Dict], max_tokens: int = 1500, temperature: float = 0.5) -> str:
+        """Faz requisição ao modelo usando chat completion - Reduzido max_tokens."""
         try:
             client = self.get_client(model_name)
             
@@ -385,9 +427,11 @@ def test_and_update_models() -> int:
     
     return len(MODELS)
 
-# --- Chat Principal ---
+# --- Chat Principal (VERSÃO CORRIGIDA) ---
 def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> str:
-    """Gera resposta como Dr. Aldo Henrique."""
+    """
+    FUNÇÃO PRINCIPAL CORRIGIDA: Gera resposta como Dr. Aldo Henrique sem duplicação.
+    """
     if not pergunta.strip():
         return "Por favor, faça uma pergunta válida."
     
@@ -400,50 +444,77 @@ def responder_como_aldo(session_id: str, pergunta: str, modelo: str = None) -> s
     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}")
-    if conversa := get_conversation_context(session_id):
-        contexto.append(f"**Conversa Anterior**\n{conversa}")
-    if blog := retrieve_context_from_blog(pergunta):
-        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), 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
-        - Faça sempre uma pequena observação que seja engraçada ou interessente relacionada a algo na pergunta.
-        - Use Markdown para formatação
-        - Adicione comentários explicativos cada parte do código
-    """
+    # === NOVA ABORDAGEM: Monta mensagens em formato adequado ===
     
-    conteudo_contexto = "\n".join(contexto)
-    mensagem_usuario = f"{conteudo_contexto}\n\n**Pergunta**: {pergunta}" if contexto else pergunta
+    # 1. Obtém mensagens anteriores da conversa (já formatadas)
+    conversation_messages = get_conversation_messages(session_id)
+    
+    # 2. Monta o system prompt (mais conciso)
+    perfil_info = get_user_profile_context(session_id)
+    
+    system_prompt = f"""Você é o Dr. Aldo Henrique, 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
+
+Informações do usuário: {perfil_info}
+
+Responda sempre em português, de forma didática e clara:
+- Explique conceitos antes de mostrar código
+- Use exemplos práticos adaptados ao nível do usuário
+- Faça uma pequena observação interessante ou engraçada relacionada à pergunta
+- Use Markdown para formatação
+- Adicione comentários explicativos no código"""
 
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": mensagem_usuario}
-    ]
+    # 3. Adiciona contexto do blog apenas se relevante (sem repetir na conversa)
+    blog_context = retrieve_context_from_blog(pergunta)
+    if blog_context:
+        system_prompt += f"\n\nContexto do seu blog (use apenas se relevante para a pergunta):\n{blog_context}"
     
-    # Faz requisição usando InferenceClient
+    # 4. Monta as mensagens finais
+    messages = [{"role": "system", "content": system_prompt}]
+    
+    # Adiciona mensagens anteriores da conversa (sem duplicação)
+    messages.extend(conversation_messages)
+    
+    # Adiciona a pergunta atual
+    messages.append({"role": "user", "content": pergunta})
+    
+    # === DEBUG: Log do que está sendo enviado ===
+    print(f"\n=== DEBUG SESSION {session_id} ===")
+    print(f"Pergunta atual: {pergunta}")
+    print(f"Mensagens na conversa: {len(conversation_messages)}")
+    print(f"Total de mensagens enviadas: {len(messages)}")
+    print("=" * 40)
+    
+    # 5. Faz requisição usando InferenceClient
     inference_client = HuggingFaceInferenceClient(HF_TOKEN)
     model_name = MODELS[modelo]
-    resposta = inference_client.query_model(model_name, messages)
+    resposta = inference_client.query_model(model_name, messages, max_tokens=1200)  # Reduzido
     
-    # Adiciona informação sobre modelo usado
-    resposta += f"\n\n*Resposta gerada pelo modelo: {modelo} ({model_name})*"
+    # 6. Limpa a resposta (remove possíveis repetições)
+    resposta_limpa = resposta.strip()
     
-    # Salva na memória
-    add_to_memory(session_id, pergunta, resposta)
-    return resposta
+    # Remove qualquer repetição óbvia da pergunta
+    if pergunta.lower() in resposta_limpa.lower()[:100]:  # Se a pergunta aparece no início
+        lines = resposta_limpa.split('\n')
+        # Remove linhas que são muito similares à pergunta
+        filtered_lines = []
+        for line in lines:
+            if not (len(line.strip()) > 0 and 
+                   any(word in line.lower() for word in pergunta.lower().split() if len(word) > 3) and
+                   len(line.strip()) < len(pergunta) * 1.5):
+                filtered_lines.append(line)
+        resposta_limpa = '\n'.join(filtered_lines).strip()
+    
+    # 7. Adiciona informação sobre modelo usado (mais discreta)
+    resposta_final = f"{resposta_limpa}\n\n*— {modelo}*"
+    
+    # 8. Salva na memória (a resposta limpa, sem a informação do modelo)
+    add_to_memory(session_id, pergunta, resposta_limpa)
+    
+    return resposta_final
 
 # --- Inicialização ---
 def inicializar_sistema():
@@ -484,7 +555,7 @@ if __name__ == "__main__":
     
     if status:
         print("\n" + "="*50)
-        print("TESTE DO SISTEMA")
+        print("TESTE DO SISTEMA CORRIGIDO")
         print("="*50)
         
         session_id = "teste_123"
@@ -494,20 +565,25 @@ if __name__ == "__main__":
         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")
+        # Teste 2 - Pergunta relacionada (para testar memória)
+        print("\n2. Testando pergunta relacionada...")
+        resposta2 = responder_como_aldo(session_id, "Como posso começar a aprender Python?")
         print(f"Resposta: {resposta2[:200]}...")
         
+        # Teste 3 - Pergunta completamente diferente
+        print("\n3. Testando pergunta diferente...")
+        resposta3 = responder_como_aldo(session_id, "Explique estruturas de dados")
+        print(f"Resposta: {resposta3[:200]}...")
+        
         # Limpeza
-        print(f"\n3. {clear_memory(session_id)}")
+        print(f"\n4. {clear_memory(session_id)}")
         
         print("\n" + "="*50)
-        print("SISTEMA PRONTO PARA USO!")
+        print("SISTEMA CORRIGIDO PRONTO!")
         print("="*50)
-        print("✓ Usando huggingface_hub.InferenceClient")
-        print("⚠ Lembre-se: nem todos os modelos podem estar funcionais.")
-        print("⚠ Teste diferentes modelos se encontrar erros.")
+        print("✓ Memória sem duplicação implementada")
+        print("✓ Contexto otimizado para reduzir tokens")
+        print("✓ Respostas mais limpas e diretas")
         
     else:
         print("\n" + "="*50)