Update ai_logic.py

ai_logic.py

@@ -1,9 +1,8 @@
-melhore esse código, as perguntas não estão sendo respondida corretamente, simplifique, a memoria tem de ser só do usuario da sessão, e não uma unica memoria geral para todos, mostre só o código completo:  import requests
 import os
-import json
 import re
 import time
 import pickle
+import requests
 from typing import Dict, Any, List, Optional, Tuple
 from bs4 import BeautifulSoup
 from urllib.parse import urljoin, urlparse
@@ -11,17 +10,20 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.vectorstores import FAISS
 from langchain.embeddings import HuggingFaceEmbeddings
 
-# --- Configuração do RAG ---
+# --- Configurações ---
+# Chave da API da Hugging Face (essencial para o funcionamento)
+HF_TOKEN = os.getenv("HF_TOKEN")
+if not HF_TOKEN:
+    raise ValueError("A variável de ambiente HF_TOKEN não foi definida. Defina-a com seu token da Hugging Face.")
+
+# URL do blog para a base de conhecimento (RAG)
 BLOG_URL = "https://aldohenrique.com.br/"
+
+# Caminhos para os arquivos do RAG
 VECTOR_STORE_PATH = "faiss_index_store.pkl"
 PROCESSED_URLS_PATH = "processed_urls.pkl"
-# CONVERSATION_MEMORY_PATH não será mais uma constante única
-
-# --- 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")
 
+# Modelos disponíveis na Hugging Face
 MODELS = {
     "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
     "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
@@ -29,593 +31,386 @@ MODELS = {
     "Gemma 7B (Google)":"google/gemma-7b-it",
     "Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta"
 }
-
 DEFAULT_MODEL = "Phi-3 Mini (Microsoft)"
 
-# --- Variáveis Globais para o RAG e Memória ---
+# --- Variáveis Globais ---
+# Armazena o índice vetorial para busca de contexto (RAG)
 vector_store: Optional[FAISS] = None
-# Dicionário para armazenar a memória de cada usuário/sessão
-# Formato: {session_id: {'conversation': List[Dict], 'user_profile': Dict}}
+
+# Dicionário para gerenciar todas as sessões de usuário em memória
+# Estrutura: {session_id: {"history": [...], "profile": {...}}}
 user_sessions: Dict[str, Dict[str, Any]] = {}
-max_memory_length = 10  # Máximo de trocas de mensagens na memória
+MAX_MEMORY_TURNS = 5  # Manter as últimas 5 trocas (usuário + assistente)
 
 # ==============================================================================
-# SEÇÃO MEMÓRIA: GERENCIAMENTO DA CONVERSA E PERFIL DO USUÁRIO
+# SEÇÃO DE GERENCIAMENTO DA SESSÃO (MEMÓRIA E PERFIL)
 # ==============================================================================
 
-def get_session_memory_path(session_id: str) -> str:
-    """Retorna o caminho do arquivo de memória para uma dada sessão."""
-    return f"conversation_memory_{session_id}.json"
-
-def load_conversation_memory(session_id: str):
-    """Carrega a memória da conversa para uma sessão específica."""
-    memory_path = get_session_memory_path(session_id)
-    session_data = {'conversation': [], 'user_profile': {}}
-
-    try:
-        if os.path.exists(memory_path):
-            with open(memory_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-                session_data['conversation'] = data.get('conversation', [])
-                session_data['user_profile'] = data.get('user_profile', {})
-            print(f"Memória para sessão '{session_id}' carregada: {len(session_data['conversation'])} mensagens")
-        else:
-            print(f"Nova conversa iniciada para sessão '{session_id}'")
-    except Exception as e:
-        print(f"Erro ao carregar memória para sessão '{session_id}': {e}")
-    
-    user_sessions[session_id] = session_data
-
-def save_conversation_memory(session_id: str):
-    """Salva a memória da conversa para uma sessão específica."""
-    memory_path = get_session_memory_path(session_id)
-    session_data = user_sessions.get(session_id, {'conversation': [], 'user_profile': {}})
-
-    try:
-        data = {
-            'conversation': session_data['conversation'],
-            'user_profile': session_data['user_profile'],
-            'last_updated': time.time()
-        }
-        with open(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 para sessão '{session_id}': {e}")
-
-def add_to_memory(session_id: str, user_message: str, assistant_response: str):
-    """Adiciona uma troca de mensagens à memória de uma sessão específica."""
-    
-    if session_id not in user_sessions:
-        load_conversation_memory(session_id) # Garante que a sessão está carregada
-
-    session_data = user_sessions[session_id]
-    conversation = session_data['conversation']
-    
-    conversation.append({
-        "role": "user",
-    ��   "content": user_message,
-        "timestamp": time.time()
-    })
-    
-    conversation.append({
-        "role": "assistant",
-        "content": assistant_response,
-        "timestamp": time.time()
-    })
-    
-    # Limita o tamanho da memória
-    if len(conversation) > max_memory_length * 2:  # *2 porque temos user + assistant
-        user_sessions[session_id]['conversation'] = conversation[-max_memory_length * 2:]
-    
-    save_conversation_memory(session_id)
+def get_or_create_session(session_id: str) -> Dict[str, Any]:
+    """
+    Obtém uma sessão de usuário existente ou cria uma nova.
+    A sessão é mantida apenas em memória.
+    """
+    if session_id not in user_sessions:
+        print(f"Nova sessão criada para o ID: {session_id}")
+        user_sessions[session_id] = {
+            "history": [],
+            "profile": {"nivel": "indefinido", "interesses": {}, "total_perguntas": 0}
+        }
+    return user_sessions[session_id]
+
+def update_memory(session_id: str, user_message: str, assistant_response: str):
+    """Adiciona a troca de mensagens ao histórico da sessão."""
+    session = get_or_create_session(session_id)
+    
+    # Adiciona as mensagens mais recentes
+    session["history"].append({"role": "user", "content": user_message})
+    session["history"].append({"role": "assistant", "content": assistant_response})
+    
+    # Garante que o histórico não exceda o tamanho máximo
+    if len(session["history"]) > MAX_MEMORY_TURNS * 2:
+        session["history"] = session["history"][-(MAX_MEMORY_TURNS * 2):]
 
 def update_user_profile(session_id: str, user_message: str):
-    """Atualiza o perfil do usuário de uma sessão específica baseado nas mensagens."""
-    if session_id not in user_sessions:
-        load_conversation_memory(session_id) # Garante que a sessão está carregada
-
-    user_profile = user_sessions[session_id]['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
-
-    user_sessions[session_id]['user_profile'] = user_profile # Atualiza no dicionário global
-
-def get_conversation_context(session_id: str) -> str:
-    """Gera um resumo do contexto da conversa para o prompt de uma sessão específica."""
-    if session_id not in user_sessions:
-        load_conversation_memory(session_id)
-
-    conversation_history = user_sessions[session_id]['conversation']
-    if not conversation_history:
-        return ""
-    
-    # Pega as últimas 6 mensagens (3 trocas)
-    recent_messages = conversation_history[-6:] if len(conversation_history) > 6 else conversation_history
-    
-    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(session_id: str) -> str:
-    """Gera informações sobre o perfil do usuário de uma sessão específica para personalizar a resposta."""
-    if session_id not in user_sessions:
-        load_conversation_memory(session_id)
-
-    user_profile = user_sessions[session_id]['user_profile']
-    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(session_id: str):
-    """Limpa a memória da conversa de uma sessão específica."""
-    memory_path = get_session_memory_path(session_id)
-
-    if session_id in user_sessions:
-        del user_sessions[session_id] # Remove da memória em tempo de execução
-    
-    try:
-        if os.path.exists(memory_path):
-            os.remove(memory_path)
-        return "✅ Memória da conversa limpa com sucesso!"
-    except Exception as e:
-        return f"❌ Erro ao limpar memória: {e}"
+    """
+    Analisa a mensagem do usuário para inferir e atualizar seu perfil de interesses e nível.
+    """
+    session = get_or_create_session(session_id)
+    profile = session["profile"]
+    msg_lower = user_message.lower()
+
+    # Atualiza contador de perguntas
+    profile["total_perguntas"] += 1
+
+    # Inferência de nível
+    if any(word in msg_lower for word in ['básico', 'iniciante', 'começar', 'o que é']):
+        profile['nivel'] = 'iniciante'
+    elif any(word in msg_lower for word in ['avançado', 'complexo', 'otimização', 'performance', 'arquitetura']):
+        profile['nivel'] = 'avançado'
+    elif profile['nivel'] == 'indefinido': # Define como intermediário se ainda não tiver um nível
+        profile['nivel'] = 'intermediário'
+
+    # Inferência de interesses
+    topics = {
+        'java': ['java', 'spring', 'jpa', 'jvm'],
+        'python': ['python', 'django', 'flask', 'pandas'],
+        'web': ['html', 'css', 'javascript', 'react', 'node'],
+        'ia': ['inteligência artificial', 'machine learning', 'llm', 'rag'],
+        'banco de dados': ['sql', 'nosql', 'mongodb', 'postgresql']
+    }
+    for topic, keywords in topics.items():
+        if any(keyword in msg_lower for keyword in keywords):
+            profile['interesses'][topic] = profile['interesses'].get(topic, 0) + 1
+
+def clear_session_memory(session_id: str) -> str:
+    """Limpa a memória de uma sessão específica."""
+    if session_id in user_sessions:
+        del user_sessions[session_id]
+        return f"✅ Memória da sessão '{session_id}' foi limpa."
+    return f"⚠️ Sessão '{session_id}' não encontrada."
+
 
 # ==============================================================================
-# SEÇÃO RAG: FUNÇÕES PARA CRAWLING, EMBEDDING E ARMAZENAMENTO (SEM ALTERAÇÕES)
+# SEÇÃO RAG: BUSCA E PROCESSAMENTO DE CONTEÚDO (SEM ALTERAÇÕES SIGNIFICATIVAS)
 # ==============================================================================
 
-def get_all_blog_links(url: str, processed_urls: set) -> set:
-    """Navega pelo blog para encontrar todos os links de posts e páginas."""
-    links_to_visit = {url}
-    visited_links = set()
-
-    while links_to_visit:
-        current_url = links_to_visit.pop()
-        if current_url in visited_links:
-            continue
-
-        try:
-            response = requests.get(current_url, timeout=10)
-            response.raise_for_status()
-            soup = BeautifulSoup(response.content, 'html.parser')
-            visited_links.add(current_url)
-            print(f"Visitando: {current_url}")
-
-            for link in soup.find_all('a', href=True):
-                href = link['href']
-                full_url = urljoin(url, href)
-                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}")
-
-    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
-
 def scrape_text_from_url(url: str) -> str:
-    """Extrai o texto principal (de artigos) de uma URL."""
-    try:
-        response = requests.get(url, timeout=10)
-        soup = BeautifulSoup(response.content, 'html.parser')
-        main_content = soup.find('article') or soup.find('main')
-        if main_content:
-            return main_content.get_text(separator='\n', strip=True)
-        return ""
-    except Exception as e:
-        print(f"Erro ao raspar {url}: {e}")
-        return ""
-
-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.
-    """
-    global vector_store
-    start_time = time.time()
-
-    print("Iniciando o processo de retreino do RAG...")
-    processed_urls = set()
-
-    all_links = get_all_blog_links(BLOG_URL, processed_urls)
-    print(f"Encontrados {len(all_links)} links para processar.")
-
-    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]
-    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
-
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
-    chunks = text_splitter.create_documents(all_texts)
-    print(f"Textos divididos em {len(chunks)} chunks.")
-
-    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)
-
-    with open(VECTOR_STORE_PATH, "wb") as f:
-        pickle.dump(vector_store, f)
-
-    with open(PROCESSED_URLS_PATH, "wb") as f:
-        pickle.dump(all_links, f)
-
-    end_time = time.time()
-    message = f"✅ Retreino do RAG concluído em {end_time - start_time:.2f} segundos. {len(chunks)} chunks de texto processados."
-    return message, VECTOR_STORE_PATH, PROCESSED_URLS_PATH
+    """Extrai texto de uma URL, focando no conteúdo principal."""
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.content, 'html.parser')
+        main_content = soup.find('article') or soup.find('main')
+        return main_content.get_text(separator='\n', strip=True) if main_content else ""
+    except requests.RequestException as e:
+        print(f"Erro ao acessar {url}: {e}")
+        return ""
+
+def build_and_save_vector_store():
+    """Coleta dados do blog, processa e cria um índice vetorial com FAISS."""
+    global vector_store
+    print("Iniciando construção do RAG...")
+    
+    # Lógica simplificada de coleta de links (pode ser expandida se necessário)
+    # Para este exemplo, vamos focar em uma URL principal
+    all_texts = [scrape_text_from_url(BLOG_URL)]
+    
+    # Adicione mais URLs manualmente se desejar
+    # additional_urls = [f"{BLOG_URL}/sobre", f"{BLOG_URL}/contato"]
+    # all_texts.extend([scrape_text_from_url(url) for url in additional_urls])
+    
+    valid_texts = [text for text in all_texts if text and len(text) > 100]
+    if not valid_texts:
+        print("Nenhum texto válido encontrado para criar o RAG.")
+        return
+
+    print(f"Processando {len(valid_texts)} página(s).")
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+    chunks = text_splitter.create_documents(valid_texts)
+
+    print(f"Criando {len(chunks)} chunks de texto.")
+    embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    vector_store = FAISS.from_documents(chunks, embeddings_model)
+
+    with open(VECTOR_STORE_PATH, "wb") as f:
+        pickle.dump(vector_store, f)
+
+    print("✅ RAG construído e salvo com sucesso!")
 
 def load_vector_store():
-    """Carrega o vector store do arquivo, se existir."""
-    global vector_store
-    if os.path.exists(VECTOR_STORE_PATH):
-        print(f"Carregando vector store existente de '{VECTOR_STORE_PATH}'...")
-        with open(VECTOR_STORE_PATH, "rb") as f:
-            vector_store = pickle.load(f)
-        print("Vector store carregado com sucesso.")
-    else:
-        print("Nenhum vector store encontrado. É necessário treinar o modelo.")
-        message, _, _ = build_and_save_vector_store()
-        print(message)
-
-def retrieve_context_from_blog(query: str, k: int = 3) -> str:
-    """Busca no vector store por chunks de texto similares à pergunta."""
-    if vector_store:
-        try:
-            results = vector_store.similarity_search(query, k=k)
-            context = "\n\n---\n\n".join([doc.page_content for doc in results])
-            return context
-        except Exception as e:
-            return f"Erro ao buscar contexto: {e}"
-    return ""
+    """Carrega o índice vetorial do disco."""
+    global vector_store
+    if os.path.exists(VECTOR_STORE_PATH):
+        print(f"Carregando RAG de '{VECTOR_STORE_PATH}'...")
+        with open(VECTOR_STORE_PATH, "rb") as f:
+            vector_store = pickle.load(f)
+        print("✅ RAG carregado.")
+    else:
+        print("Índice RAG não encontrado. Construindo um novo...")
+        build_and_save_vector_store()
+
+def retrieve_rag_context(query: str, k: int = 3) -> str:
+    """Busca no RAG por contexto relevante para a pergunta."""
+    if vector_store:
+        try:
+            results = vector_store.similarity_search(query, k=k)
+            return "\n\n---\n\n".join([doc.page_content for doc in results])
+        except Exception as e:
+            print(f"Erro ao buscar contexto no RAG: {e}")
+    return ""
 
 # ==============================================================================
-# SEÇÃO API CLIENT: CÓDIGO ORIGINAL PARA CHAMAR A API DO HUGGING FACE
+# SEÇÃO DA API E CONSTRUÇÃO DO PROMPT
 # ==============================================================================
 
 class HuggingFaceAPIClient:
-    def __init__(self, token: str):
-        self.token = token
-        self.headers = {
-            "Authorization": f"Bearer {token}",
-            "Content-Type": "application/json"
-        }
-
-    def query_model(self, model_name: str, messages: list, max_tokens: int = 1500) -> str:
-        """Faz requisição para a API do Hugging Face"""
-        url = f"https://api-inference.huggingface.co/models/{model_name}/v1/chat/completions"
-        payload = {
-            "model": model_name,
-            "messages": messages,
-            "max_tokens": max_tokens,
-            "temperature": 0.7,
-            "top_p": 0.9,
-            "stream": False
-        }
-        try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=9999)
-            if response.status_code == 200:
-                result = response.json()
-                return result["choices"][0]["message"]["content"]
-            else:
-                return self._fallback_text_generation(model_name, messages, max_tokens)
-        except Exception as e:
-            return f"Erro na API: {str(e)}"
-
-    def _fallback_text_generation(self, model_name: str, messages: list, max_tokens: int) -> str:
-        url = f"https://api-inference.huggingface.co/models/{model_name}"
-        prompt = self._messages_to_prompt(messages)
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": max_tokens, "temperature": 0.7, "top_p": 0.9,
-                "do_sample": True, "return_full_text": False
-            },
-            "options": {"wait_for_model": True, "use_cache": False}
-        }
-        try:
-            response = requests.post(url, headers=self.headers, json=payload, timeout=9999)
-            if response.status_code == 200:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    generated_text = result[0].get("generated_text", "")
-                    if generated_text:
-                        if "Assistente: " in generated_text:
-                            parts = generated_text.split("Assistente: ")
-                            if len(parts) > 1: return parts[-1].strip()
-                        return generated_text.strip()
-                    return "Resposta vazia"
-                elif isinstance(result, dict):
-                    if "error" in result: return f"Erro do modelo: {result['error']}"
-                    elif "generated_text" in result: return result["generated_text"].strip()
-                return "Formato de resposta inesperado"
-            elif response.status_code == 404: return f"❌ Modelo '{model_name}' não encontrado."
-            elif response.status_code == 503: return "⏳ Modelo carregando... Tente novamente."
-            elif response.status_code == 429: return "⚠️ Muitas requisições. Tente novamente."
-            else: return f"Erro HTTP {response.status_code}: {response.text[:200]}..."
-        except requests.Timeout:
-            return "⏰ Timeout - Modelo demorou muito para responder."
-        except Exception as e:
-            return f"Erro na requisição: {str(e)}"
-
-    def _messages_to_prompt(self, messages: list) -> str:
-        prompt = ""
-        for msg in messages:
-            prompt += f"{msg['role'].capitalize()}: {msg['content']}\n\n"
-        prompt += "Assistente: "
-        return prompt
-
-# Inicializar cliente da API
-api_client = HuggingFaceAPIClient(HF_TOKEN)
+    """Cliente para interagir com a API de Inferência da Hugging Face."""
+    def __init__(self, token: str):
+        self.headers = {"Authorization": f"Bearer {token}", "Content-Type": "application/json"}
+
+    def query(self, model_id: str, messages: List[Dict[str, str]], max_tokens: int = 2048) -> str:
+        api_url = f"https://api-inference.huggingface.co/models/{model_id}"
+        payload = {
+            "inputs": self._format_prompt_for_model(messages),
+            "parameters": {
+                "max_new_tokens": max_tokens,
+                "temperature": 0.7,
+                "top_p": 0.95,
+                "return_full_text": False,
+            },
+            "options": {"wait_for_model": True}
+        }
+        try:
+            response = requests.post(api_url, headers=self.headers, json=payload, timeout=60)
+            response.raise_for_status()
+            result = response.json()
+            # A resposta da API de inferência pode vir em uma lista
+            if isinstance(result, list) and result:
+                return result[0].get("generated_text", "").strip()
+            # Ou em um dicionário
+            elif isinstance(result, dict):
+                 return result.get("generated_text", f"Erro: Resposta inesperada do modelo: {result.get('error', '')}").strip()
+            return "Erro: Resposta vazia ou em formato inesperado."
+        except requests.Timeout:
+            return "Erro: A requisição à API demorou muito para responder (timeout)."
+        except requests.HTTPError as http_err:
+            return f"Erro HTTP: {http_err}. Detalhes: {response.text}"
+        except Exception as e:
+            return f"Ocorreu um erro inesperado na chamada da API: {e}"
+
+    def _format_prompt_for_model(self, messages: List[Dict[str, str]]) -> str:
+        """Formata a lista de mensagens em uma string única para a API de inferência."""
+        prompt_str = ""
+        for msg in messages:
+            if msg['role'] == 'system':
+                prompt_str += f"<|system|>\n{msg['content']}</s>\n"
+            elif msg['role'] == 'user':
+                prompt_str += f"<|user|>\n{msg['content']}</s>\n"
+            elif msg['role'] == 'assistant':
+                 prompt_str += f"<|assistant|>\n{msg['content']}</s>\n"
+        prompt_str += "<|assistant|>\n" # Solicita a continuação do assistente
+        return prompt_str
+
+
+class PromptBuilder:
+    """Constrói o prompt final a ser enviado para o modelo."""
+    
+    SYS_PROMPT_TEMPLATE = """Você é o Professor Aldo, um especialista em programação (Java, C, Web) e IA.
+
+**Sua Personalidade:**
+- **Didático e Paciente:** Aja como um professor experiente. Explique o "porquê" das coisas, não apenas o "como".
+- **Acolhedor e Amigável:** Use uma linguagem calorosa e acessível.
+- **Adaptável:** Ajuste a complexidade da sua resposta ao nível de conhecimento do aluno.
+- **Contextual:** Se a pergunta atual se conectar a algo que já discutimos, mencione essa conexão.
+
+**Suas Regras:**
+1.  Responda sempre em português do Brasil.
+2.  Use blocos de código (```java, ```python, etc.) para exemplos. Comente o código para explicar cada parte.
+3.  Se a pergunta não for sobre tecnologia ou programação, educadamente informe que sua especialidade é outra.
+4.  Baseie sua resposta primariamente nas informações do seu blog (se houver contexto) e no nosso histórico de conversa.
+
+A seguir, informações para te ajudar a contextualizar sua resposta:"""
+
+    def __init__(self, session_id: str, rag_context: str):
+        self.session = get_or_create_session(session_id)
+        self.rag_context = rag_context
+        self.parts = []
+
+    def _add_profile_context(self):
+        profile = self.session["profile"]
+        if profile["total_perguntas"] > 0:
+            profile_summary = [f"**Perfil do Aluno (Inferido):**"]
+            profile_summary.append(f"- Nível de conhecimento: {profile['nivel'].capitalize()}")
+            interesses = sorted(profile['interesses'].items(), key=lambda item: item[1], reverse=True)
+            if interesses:
+                formatted_interesses = [f"{topic.capitalize()} ({count}x)" for topic, count in interesses]
+                profile_summary.append(f"- Principais interesses: {', '.join(formatted_interesses)}")
+            self.parts.append("\n".join(profile_summary))
+    
+    def _add_rag_context(self):
+        if self.rag_context:
+            self.parts.append(f"**Contexto Relevante do seu Blog (RAG):**\n{self.rag_context}")
+
+    def _add_history_context(self, current_question: str) -> List[Dict[str, str]]:
+        """Prepara o histórico de mensagens para o modelo."""
+        history = self.session.get("history", [])
+        # Pega as mensagens do histórico e adiciona a pergunta atual
+        messages = history + [{"role": "user", "content": current_question}]
+        return messages
+
+    def build(self, user_question: str) -> List[Dict[str, str]]:
+        # Adiciona os contextos ao prompt do sistema
+        self._add_profile_context()
+        self._add_rag_context()
+
+        system_content = self.SYS_PROMPT_TEMPLATE
+        if self.parts:
+            system_content += "\n\n" + "\n\n".join(self.parts)
+
+        # Monta a lista final de mensagens
+        messages = [{"role": "system", "content": system_content}]
+        messages.extend(self._add_history_context(user_question))
+        
+        return messages
 
 # ==============================================================================
-# SEÇÃO PRINCIPAL: LÓGICA DO CHATBOT COM MEMÓRIA POR USUÁRIO
+# FUNÇÃO PRINCIPAL E INICIALIZAÇÃO
 # ==============================================================================
 
-def formatar_resposta_com_codigo(resposta: str) -> str:
-    """Formata a resposta destacando códigos em blocos separados."""
-    if not resposta: return resposta
-    
-    resposta = resposta.replace('<', '&lt;').replace('>', '&gt;')    
-    resposta_formatada = re.sub(
-        r'```(\w+)?\n(.*?)\n```',
-        r'<div style="background-color: #f8f9fa; color: #1a1a1a; border: 1px solid #e9ecef; border-radius: 8px; padding: 15px; margin: 10px 0; font-family: Monaco, Consolas, monospace; overflow-x: auto;"><strong style="color: #1a1a1a;">💻 Código:</strong><br><pre style="color: #1a1a1a; margin: 5px 0; white-space: pre-wrap; word-wrap: break-word;"><code>\2</code></pre></div>',
-        resposta, flags=re.DOTALL
-    )
-    resposta_formatada = re.sub(
-        r'`([^`]+)`',
-        r'<code style="background-color: #f1f3f4; color: #1a1a1a; padding: 2px 4px; border-radius: 4px; font-family: Monaco, Consolas, monospace;">\1</code>',
-        resposta_formatada
-    )
-    resposta_formatada = resposta_formatada.replace('\n', '<br>')
-    resposta_formatada = re.sub(
-        r'^\*\*(.*?)\*\*',
-        r'<h3 style="color: #1a1a1a; margin-top: 20px; margin-bottom: 10px;">\1</h3>',
-        resposta_formatada, flags=re.MULTILINE
-    )
-    return resposta_formatada
-
-def responder_como_aldo(session_id: str, pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) -> str:
-    """Função principal para gerar respostas, agora com RAG e MEMÓRIA por sessão."""
-    if not pergunta.strip():
-        return "Por favor, faça uma pergunta."
-
-    try:
-        # Garante que a sessão do usuário está carregada
-        if session_id not in user_sessions:
-            load_conversation_memory(session_id)
-        
-        # Atualiza o perfil do usuário baseado na pergunta
-        update_user_profile(session_id, pergunta)
-        
-        # --- ETAPA DE RAG ---
-        print(f"Buscando contexto para a pergunta: '{pergunta[:50]}...' para sessão '{session_id}'")
-        contexto_blog = retrieve_context_from_blog(pergunta)
-        
-        # --- ETAPA DE MEMÓRIA ---
-        contexto_conversa = get_conversation_context(session_id)
-        contexto_perfil = get_user_profile_context(session_id)
-        
-        # Prompt do sistema personalizado baseado no perfil do usuário
-        nivel = user_sessions[session_id]['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 = []
-        
-        if contexto_perfil:
-            prompt_parts.append(contexto_perfil)
-        
-        if contexto_conversa:
-            prompt_parts.append(contexto_conversa)
-            
-        if contexto_blog:
-            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}
-        ]
-        
-        model_name = MODELS.get(modelo_escolhido, MODELS[DEFAULT_MODEL])
-        resposta = api_client.query_model(model_name, messages)
-        
-        if resposta.startswith("Assistente: "):
-            resposta = resposta.replace("Assistente: ", "")
-        
-        # Adiciona a conversa à memória da sessão
-        add_to_memory(session_id, 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)}"
+# Inicializa o cliente da API
+api_client = HuggingFaceAPIClient(token=HF_TOKEN)
+
+def formatar_resposta(resposta: str) -> str:
+    """Formata a resposta com HTML para melhor visualização de código e texto."""
+    resposta_html = resposta.replace('<', '&lt;').replace('>', '&gt;')
+    
+    # Formata blocos de código
+    resposta_html = re.sub(
+        r'```(\w+)?\n(.*?)\n```',
+        r'<div style="background-color:#f0f0f0; border:1px solid #ddd; border-radius:8px; padding:15px; margin:1em 0; font-family:monospace; color:black;"><pre><code>\2</code></pre></div>',
+        resposta_html,
+        flags=re.DOTALL
+    )
+    # Formata negrito
+    resposta_html = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', resposta_html)
+    # Formata nova linha
+    return resposta_html.replace('\n', '<br>')
+
+def responder_pergunta(session_id: str, pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) -> str:
+    """
+    Função principal que orquestra todo o processo de resposta.
+    """
+    if not pergunta.strip():
+        return "Por favor, faça uma pergunta."
+
+    print(f"\n--- Processando pergunta para a sessão: {session_id} ---")
+
+    # 1. Atualizar perfil do usuário com base na pergunta atual
+    update_user_profile(session_id, pergunta)
+
+    # 2. Buscar contexto relevante no RAG
+    print("Buscando no RAG...")
+    rag_context = retrieve_rag_context(pergunta)
+    if rag_context:
+        print("Contexto encontrado no RAG.")
+
+    # 3. Construir o prompt completo usando o PromptBuilder
+    print("Construindo prompt...")
+    builder = PromptBuilder(session_id, rag_context)
+    messages = builder.build(pergunta)
+    
+    # DEBUG: Descomente a linha abaixo para ver o prompt exato enviado ao modelo
+    # print("MENSAGENS ENVIADAS AO MODELO:", json.dumps(messages, indent=2, ensure_ascii=False))
+
+    # 4. Chamar a API da Hugging Face
+    print(f"Enviando para o modelo '{modelo_escolhido}'...")
+    model_id = MODELS.get(modelo_escolhido, MODELS[DEFAULT_MODEL])
+    resposta_bruta = api_client.query(model_id, messages)
+    
+    # 5. Adicionar a interação à memória da sessão
+    update_memory(session_id, pergunta, resposta_bruta)
+
+    # 6. Formatar e retornar a resposta
+    return formatar_resposta(resposta_bruta)
 
-# ==============================================================================
-# FUNÇÕES AUXILIARES E DE TESTE
-# ==============================================================================
+def inicializar_sistema():
+    """Carrega o RAG ao iniciar."""
+    print("🚀 Inicializando o sistema...")
+    load_vector_store()
+    print("✅ Sistema pronto para uso.")
 
-def verificar_modelo_disponivel(model_name: str) -> str:
-    try:
-        url = f"[https://api-inference.huggingface.co/models/](https://api-inference.huggingface.co/models/){model_name}"
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        payload = {"inputs": "Hello", "parameters": {"max_new_tokens": 5}}
-        response = requests.post(url, headers=headers, json=payload, timeout=9999)
-        if response.status_code == 200: return "✅ Disponível"
-        elif response.status_code == 404: return "❌ Não encontrado"
-        elif response.status_code == 503: return "⏳ Carregando..."
-        else: return f"⚠️ Status {response.status_code}"
-    except Exception as e:
-        return f"❌ Erro: {str(e)[:50]}..."
-
-def testar_todos_modelos():
-    resultados = []
-    for nome, modelo in MODELS.items():
-        status = verificar_modelo_disponivel(modelo)
-        resultados.append(f"{nome}: {status}")
-    return "\n".join(resultados)
-
-def get_memory_stats(session_id: str) -> str:
-    """Retorna estatísticas da memória atual para uma sessão específica."""
-    if session_id not in user_sessions:
-        load_conversation_memory(session_id)
-
-    session_data = user_sessions[session_id]
-    conversation_history = session_data['conversation']
-    user_profile = session_data['user_profile']
-
-    total_messages = len(conversation_history)
-    user_messages = len([m for m in conversation_history if m["role"] == "user"])
-    
-    stats = f"📊 **Estatísticas da Memória para Sessão '{session_id}':**\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
+# BLOCO DE TESTE
 # ==============================================================================
 
-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()
-    
-    # **NÃO CARREGAMOS MAIS UMA MEMÓRIA GLOBAL AQUI**
-    # A memória será carregada e gerenciada por sessão individualmente
-    
-    print("✅ Sistema inicializado com sucesso!")
-    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()
-    
-    # Exemplo de uso para testar com sessões diferentes:
-    print("\n--- Testando sessões independentes ---")
-    
-    # Simulando um usuário A
-    session_id_a = "user_A_session_123"
-    print(f"\nUsuário A ({session_id_a}):")
-    print(responder_como_aldo(session_id_a, "Olá, o que é Java?"))
-    print(responder_como_aldo(session_id_a, "Pode me dar um exemplo de código Java para 'Hello World'?"))
-    print(get_memory_stats(session_id_a))
-
-    # Simulando um usuário B
-    session_id_b = "user_B_session_456"
-    print(f"\nUsuário B ({session_id_b}):")
-    print(responder_como_aldo(session_id_b, "Qual a diferença entre IA e Machine Learning?"))
-    print(get_memory_stats(session_id_b))
-
-    # Usuário A continua sua conversa
-    print(f"\nUsuário A ({session_id_a}) continua:")
-    print(responder_como_aldo(session_id_a, "E sobre polimorfismo em Java?"))
-    print(get_memory_stats(session_id_a))
-
-    # Limpar a memória de uma sessão específica
-    print(f"\nLimpando memória do Usuário B ({session_id_b}):")
-    print(clear_memory(session_id_b))
-    print(get_memory_stats(session_id_b)) # Deve mostrar memória vazia ou não encontrada para B
-
-    # Usuário A ainda tem sua memória
-    print(f"\nVerificando memória do Usuário A ({session_id_a}) após limpar B:")
-    print(get_memory_stats(session_id_a))
+    inicializar_sistema()
+    
+    # --- Simulação de Conversas ---
+    
+    # Sessão do Usuário A (interessado em Java)
+    session_a = "aluno_java_123"
+    print("\n--- INÍCIO DA CONVERSA COM ALUNO A (Java) ---")
+    
+    pergunta1_a = "Olá! Pode me explicar o que é Polimorfismo em Java de uma forma simples?"
+    resposta1_a = responder_pergunta(session_a, pergunta1_a)
+    print(f"ALUNO A: {pergunta1_a}\nPROFESSOR ALDO:\n{resposta1_a}\n")
+
+    pergunta2_a = "Entendi! Pode me dar um exemplo de código com classes e herança para ilustrar?"
+    resposta2_a = responder_pergunta(session_a, pergunta2_a)
+    print(f"ALUNO A: {pergunta2_a}\nPROFESSOR ALDO:\n{resposta2_a}\n")
+
+    # Sessão do Usuário B (interessado em IA)
+    session_b = "aluna_ia_456"
+    print("\n--- INÍCIO DA CONVERSA COM ALUNA B (IA) ---")
+
+    pergunta1_b = "Oi, professor! Eu sou nova na área. Qual a diferença entre Inteligência Artificial e Machine Learning?"
+    resposta1_b = responder_pergunta(session_b, pergunta1_b)
+    print(f"ALUNA B: {pergunta1_b}\nPROFESSOR ALDO:\n{resposta1_b}\n")
+    
+    # Usuário A continua sua conversa, a memória do usuário B não deve interferir
+    print("\n--- ALUNO A CONTINUA SUA CONVERSA ---")
+    pergunta3_a = "Faz sentido. E como o conceito de 'override' se encaixa nisso que acabamos de ver?"
+    resposta3_a = responder_pergunta(session_a, pergunta3_a)
+    print(f"ALUNO A: {pergunta3_a}\nPROFESSOR ALDO:\n{resposta3_a}\n")
+
+    # Exibe o estado final das sessões
+    print("\n--- ESTADO FINAL DAS SESSÕES EM MEMÓRIA ---")
+    print(f"\nSessão A ({session_a}):")
+    # print(json.dumps(user_sessions.get(session_a), indent=2, ensure_ascii=False))
+    print(f"  Nível: {user_sessions[session_a]['profile']['nivel']}")
+    print(f"  Interesses: {user_sessions[session_a]['profile']['interesses']}")
+    print(f"  Tamanho do Histórico: {len(user_sessions[session_a]['history'])} mensagens")
+
+
+    print(f"\nSessão B ({session_b}):")
+    # print(json.dumps(user_sessions.get(session_b), indent=2, ensure_ascii=False))
+    print(f"  Nível: {user_sessions[session_b]['profile']['nivel']}")
+    print(f"  Interesses: {user_sessions[session_b]['profile']['interesses']}")
+    print(f"  Tamanho do Histórico: {len(user_sessions[session_b]['history'])} mensagens")
+    
+    # Limpando a memória de uma sessão
+    print("\n--- LIMPANDO MEMÓRIA ---")
+    print(clear_session_memory(session_a))
+    print(f"Sessões ativas agora: {list(user_sessions.keys())}")