Update ai_logic.py

ai_logic.py

@@ -11,611 +11,359 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.vectorstores import FAISS
 from langchain.embeddings import HuggingFaceEmbeddings
 
-# --- Configuração do RAG ---
-BLOG_URL = "https://aldohenrique.com.br/"
-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")
-
-MODELS = {
-    "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
-    "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
-    "Deepseek (chat) 7B": "deepseek-ai/deepseek-vl-7b-chat",
-    "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 ---
-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}}
-user_sessions: Dict[str, Dict[str, Any]] = {}
-max_memory_length = 10  # Máximo de trocas de mensagens na memória
-
 # ==============================================================================
-# SEÇÃO MEMÓRIA: GERENCIAMENTO DA CONVERSA E PERFIL DO USUÁRIO
+# SEÇÃO 1: CONFIGURAÇÃO CENTRALIZADA
 # ==============================================================================
 
-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 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']
+class Config:
+    """Classe para centralizar todas as configurações do sistema."""
+    # Configuração do RAG
+    BLOG_URL = "https://aldohenrique.com.br/"
+    VECTOR_STORE_PATH = "faiss_index_store.pkl"
+    PROCESSED_URLS_PATH = "processed_urls.pkl"
+
+    # Configuração da Memória de Sessão
+    SESSION_MEMORY_DIR = "session_memories"
+    MAX_MEMORY_LENGTH = 10  # Máximo de trocas de mensagens (user + assistant)
+
+    # Configuração da API Hugging Face
+    HF_TOKEN = os.getenv("HF_TOKEN")
+    MODELS = {
+        "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
+        "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
+        "Gemma 7B (Google)": "google/gemma-7b-it",
     }
-    
-    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
+    DEFAULT_MODEL = "Phi-3 Mini (Microsoft)"
+    API_TIMEOUT = 45 # Timeout de 45 segundos para a API
 
-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)
+    def __init__(self):
+        if not self.HF_TOKEN:
+            raise ValueError("Token HF_TOKEN não encontrado nas variáveis de ambiente.")
+        os.makedirs(self.SESSION_MEMORY_DIR, exist_ok=True)
 
-    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
+# ==============================================================================
+# SEÇÃO 2: GERENCIAMENTO DE MEMÓRIA POR SESSÃO
+# ==============================================================================
 
-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)
+class SessionManager:
+    """Gerencia a memória da conversa e o perfil de cada usuário/sessão."""
+    def __init__(self, config: Config):
+        self.config = config
+        self._sessions: Dict[str, Dict[str, Any]] = {}
+
+    def _get_memory_path(self, session_id: str) -> str:
+        """Retorna o caminho do arquivo de memória para uma sessão."""
+        return os.path.join(self.config.SESSION_MEMORY_DIR, f"memory_{session_id}.json")
+
+    def get_session(self, session_id: str) -> Dict[str, Any]:
+        """Carrega uma sessão da memória ou do disco, se não estiver carregada."""
+        if session_id not in self._sessions:
+            try:
+                with open(self._get_memory_path(session_id), 'r', encoding='utf-8') as f:
+                    self._sessions[session_id] = json.load(f)
+                print(f"Memória para sessão '{session_id}' carregada do disco.")
+            except (FileNotFoundError, json.JSONDecodeError):
+                print(f"Nova conversa iniciada para sessão '{session_id}'.")
+                self._sessions[session_id] = {'conversation': [], 'user_profile': {'nivel': 'intermediario'}}
+        return self._sessions[session_id]
+
+    def save_session(self, session_id: str):
+        """Salva o estado atual de uma sessão em um arquivo JSON."""
+        if session_id in self._sessions:
+            try:
+                with open(self._get_memory_path(session_id), 'w', encoding='utf-8') as f:
+                    json.dump(self._sessions[session_id], f, ensure_ascii=False, indent=2)
+            except IOError as e:
+                print(f"Erro ao salvar memória para sessão '{session_id}': {e}")
+
+    def add_to_memory(self, session_id: str, user_message: str, assistant_response: str):
+        """Adiciona uma nova troca de mensagens à memória da sessão."""
+        session = self.get_session(session_id)
+        conversation = session.get('conversation', [])
+        
+        conversation.append({"role": "user", "content": user_message})
+        conversation.append({"role": "assistant", "content": assistant_response})
+        
+        # Limita o tamanho da memória
+        if len(conversation) > self.config.MAX_MEMORY_LENGTH * 2:
+            session['conversation'] = conversation[-self.config.MAX_MEMORY_LENGTH * 2:]
+            
+        self.update_user_profile(session_id, user_message)
+        self.save_session(session_id) # Salva após a atualização
+
+    def update_user_profile(self, session_id: str, user_message: str):
+        """Atualiza o perfil do usuário com base em heurísticas simples."""
+        session = self.get_session(session_id)
+        profile = session.get('user_profile', {})
+        msg_lower = user_message.lower()
+
+        # Atualiza nível de conhecimento
+        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', 'arquitetura']):
+            profile['nivel'] = 'avançado'
+        
+        profile['total_perguntas'] = profile.get('total_perguntas', 0) + 1
+        session['user_profile'] = profile
 
-    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}"
+    def clear_memory(self, session_id: str):
+        """Limpa a memória de uma sessão específica (em RAM e em disco)."""
+        if session_id in self._sessions:
+            del self._sessions[session_id]
+        
+        try:
+            os.remove(self._get_memory_path(session_id))
+            return f"✅ Memória da sessão '{session_id}' limpa com sucesso!"
+        except FileNotFoundError:
+            return f"⚠️ Nenhuma memória em disco encontrada para a sessão '{session_id}'."
+        except Exception as e:
+            return f"❌ Erro ao limpar memória da sessão '{session_id}': {e}"
 
 # ==============================================================================
-# SEÇÃO RAG: FUNÇÕES PARA CRAWLING, EMBEDDING E ARMAZENAMENTO (SEM ALTERAÇÕES)
+# SEÇÃO 3: SISTEMA DE RAG (Retrieval-Augmented Generation)
 # ==============================================================================
 
-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
+class RAGSystem:
+    """Gerencia a criação, carregamento e busca no Vector Store do blog."""
+    def __init__(self, config: Config):
+        self.config = config
+        self.vector_store: Optional[FAISS] = None
+        self.embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
+    def load(self):
+        """Carrega o vector store do disco ou o constrói se não existir."""
         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)
+            with open(self.config.VECTOR_STORE_PATH, "rb") as f:
+                self.vector_store = pickle.load(f)
+            print("✅ Vector Store carregado com sucesso do disco.")
+        except FileNotFoundError:
+            print("⚠️ Vector Store não encontrado. Iniciando processo de construção.")
+            self.build()
+
+    def build(self):
+        """Coleta dados do blog, cria embeddings e salva o vector store."""
+        print("Iniciando construção do RAG...")
+        # 1. Coletar links
+        response = requests.get(self.config.BLOG_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}")
+        links = {urljoin(self.config.BLOG_URL, a['href']) for a in soup.find_all('a', href=True)}
+        # Filtro simples para pegar apenas posts
+        post_links = {link for link in links if urlparse(link).path.count('/') > 2 and '?' not in link}
+        print(f"Encontrados {len(post_links)} links de posts para processar.")
+
+        # 2. Extrair texto
+        texts = []
+        for link in post_links:
+            try:
+                page_response = requests.get(link, timeout=10)
+                page_soup = BeautifulSoup(page_response.content, 'html.parser')
+                article = page_soup.find('article') or page_soup.find('main')
+                if article:
+                    texts.append(article.get_text(separator='\n', strip=True))
+            except requests.RequestException:
+                continue # Ignora links que falham
+        
+        if not texts:
+            print("❌ Nenhum texto pôde ser extraído. A construção do RAG falhou.")
+            return
+
+        # 3. Criar chunks
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+        chunks = text_splitter.create_documents(texts)
+        print(f"Textos divididos em {len(chunks)} chunks.")
+        
+        # 4. Criar e salvar Vector Store
+        self.vector_store = FAISS.from_documents(chunks, self.embeddings_model)
+        with open(self.config.VECTOR_STORE_PATH, "wb") as f:
+            pickle.dump(self.vector_store, f)
+        print("✅ Novo Vector Store construído e salvo com sucesso!")
+
+    def retrieve(self, query: str, k: int = 3) -> str:
+        """Busca no vector store por chunks de texto relevantes para a query."""
+        if self.vector_store:
+            results = self.vector_store.similarity_search(query, k=k)
+            return "\n\n---\n\n".join([doc.page_content for doc in results])
         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
-
-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 ""
-
 # ==============================================================================
-# SEÇÃO API CLIENT: CÓDIGO ORIGINAL PARA CHAMAR A API DO HUGGING FACE
+# SEÇÃO 4: CLIENTE DA API E LÓGICA PRINCIPAL DO CHATBOT
 # ==============================================================================
 
 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)
+    """Cliente simplificado para interagir com a API de chat do Hugging Face."""
+    def __init__(self, config: Config):
+        self.config = config
+        self.headers = {"Authorization": f"Bearer {config.HF_TOKEN}"}
+
+    def query(self, model_name: str, messages: list) -> str:
+        """Envia a requisição para o endpoint de chat/completions."""
+        api_url = f"https://api-inference.huggingface.co/models/{model_name}"
         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}
+            "inputs": messages,
+            "parameters": {"max_new_tokens": 1500, "temperature": 0.7, "return_full_text": False},
+            "options": {"wait_for_model": True}
         }
         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)}"
+            response = requests.post(api_url, headers=self.headers, json=payload, timeout=self.config.API_TIMEOUT)
+            response.raise_for_status() # Lança exceção para códigos de erro HTTP
+            result = response.json()
 
-    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
+            # A resposta pode vir em formatos diferentes dependendo do modelo
+            if isinstance(result, list) and result and "generated_text" in result[0]:
+                return result[0]["generated_text"].strip()
+            # Tratamento para alguns modelos que podem encapsular a resposta de outra forma
+            if isinstance(result, dict) and "generated_text" in result:
+                 return result["generated_text"].strip()
 
-# Inicializar cliente da API
-api_client = HuggingFaceAPIClient(HF_TOKEN)
+            return f"Resposta inesperada da API: {str(result)[:200]}"
 
-# ==============================================================================
-# SEÇÃO PRINCIPAL: LÓGICA DO CHATBOT COM MEMÓRIA POR USUÁRIO
-# ==============================================================================
-
-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)
+        except requests.Timeout:
+            return "⏰ Erro: A API demorou muito para responder (timeout)."
+        except requests.HTTPError as e:
+            return f"❌ Erro HTTP {e.response.status_code}: {e.response.text[:200]}"
+        except Exception as e:
+            return f"💥 Erro inesperado ao contatar a API: {str(e)}"
+
+class AldoChatbot:
+    """Orquestra o RAG, a Memória e a chamada à API para gerar respostas."""
+    def __init__(self, config: Config, session_manager: SessionManager, rag_system: RAGSystem, api_client: HuggingFaceAPIClient):
+        self.config = config
+        self.session_manager = session_manager
+        self.rag_system = rag_system
+        self.api_client = api_client
+
+    def _format_response(self, text: str) -> str:
+        """Formata a resposta com HTML simples para código e negrito."""
+        # Escapa caracteres HTML básicos para segurança
+        text = text.replace('<', '&lt;').replace('>', '&gt;')
         
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": pergunta_completa}
-        ]
+        # Formata blocos de código ```...```
+        text = re.sub(
+            r'```(\w*?)\n(.*?)```',
+            r'<div style="background-color:#f0f0f0; border-radius:5px; padding:10px; margin:10px 0; font-family:monospace; color:black;"><pre><code>\2</code></pre></div>',
+            text,
+            flags=re.DOTALL
+        )
+        # Formata títulos **...**
+        text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', text)
+        return text.replace('\n', '<br>')
+
+    def get_response(self, session_id: str, user_question: str, model_key: str) -> str:
+        """Processo completo para gerar uma resposta para o usuário."""
+        if not user_question.strip():
+            return "Por favor, faça uma pergunta."
+
+        session = self.session_manager.get_session(session_id)
+        user_profile = session.get('user_profile', {})
+        conversation_history = session.get('conversation', [])
         
-        model_name = MODELS.get(modelo_escolhido, MODELS[DEFAULT_MODEL])
-        resposta = api_client.query_model(model_name, messages)
+        # 1. RAG: Buscar contexto no blog
+        rag_context = self.rag_system.retrieve(user_question)
         
-        if resposta.startswith("Assistente: "):
-            resposta = resposta.replace("Assistente: ", "")
+        # 2. PROMPT ENGINEERING: Montar a estrutura de mensagens
+        system_prompt = f"""Você é o professor Dr. Aldo Henrique, um especialista em programação (C, Java, Web) e IA.
+- Personalidade: Paciente, amigável e didático.
+- Nível do Aluno: Adapte sua linguagem para o nível '{user_profile.get('nivel', 'intermediario')}'.
+- Regras: Responda em português do Brasil. Use blocos de código (```) para exemplos. Explique conceitos de forma clara com analogias.
+- Fonte de Conhecimento: Baseie-se PRINCIPALMENTE no contexto fornecido do seu blog. Se o contexto não for suficiente, use seu conhecimento geral, mas informe que a informação não veio do blog."""
+
+        # Mensagens para o modelo
+        messages = [{"role": "system", "content": system_prompt}]
         
-        # Adiciona a conversa à memória da sessão
-        add_to_memory(session_id, pergunta, resposta)
+        # Adiciona histórico da conversa (se houver)
+        messages.extend(conversation_history)
+
+        # Constrói a pergunta final do usuário com o contexto do RAG
+        final_user_content = f"""
+**Contexto do meu blog para consulta:**
+---
+{rag_context if rag_context else "Nenhum contexto relevante encontrado no blog."}
+---
+
+**Minha pergunta é:**
+{user_question}
+"""
+        messages.append({"role": "user", "content": final_user_content})
         
-        resposta_formatada = formatar_resposta_com_codigo(resposta.strip())
-        return resposta_formatada
+        # 3. API: Chamar o modelo de linguagem
+        model_id = self.config.MODELS.get(model_key, self.config.MODELS[self.config.DEFAULT_MODEL])
         
-    except Exception as e:
-        return f"Erro ao processar sua pergunta: {str(e)}"
+        print(f"Enviando para o modelo '{model_id}'...")
+        assistant_response = self.api_client.query(model_id, messages)
+
+        # 4. MEMÓRIA: Salvar a interação
+        self.session_manager.add_to_memory(session_id, user_question, assistant_response)
+
+        # 5. FORMATAÇÃO: Formatar a resposta final para exibição
+        return self._format_response(assistant_response)
 
 # ==============================================================================
-# FUNÇÕES AUXILIARES E DE TESTE
+# SEÇÃO 5: INICIALIZAÇÃO E EXECUÇÃO
 # ==============================================================================
 
-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"])
+if __name__ == "__main__":
+    print("🚀 Inicializando o Chatbot Dr. Aldo Henrique...")
     
-    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"
+    # 1. Inicializar componentes
+    config = Config()
+    session_manager = SessionManager(config)
+    rag_system = RAGSystem(config)
+    api_client = HuggingFaceAPIClient(config)
     
-    # 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})")
+    # 2. Carregar ou construir RAG
+    rag_system.load()
     
-    if interesses:
-        stats += f"• Principais interesses: {', '.join(interesses)}\n"
+    # 3. Inicializar o chatbot principal
+    chatbot = AldoChatbot(config, session_manager, rag_system, api_client)
     
-    return stats
-
-# ==============================================================================
-# INICIALIZAÇÃO DO SISTEMA
-# ==============================================================================
+    print("\n✅ Sistema pronto para uso.")
+    print("--- Início dos Testes de Sessão ---")
 
-def inicializar_sistema():
-    """Inicializa todos os componentes do sistema."""
-    print("🚀 Inicializando o Chatbot Dr. Aldo Henrique com Memória...")
+    # --- SIMULAÇÃO DO USUÁRIO A ---
+    session_a = "usuario_alfa_001"
+    print(f"\n--- [Sessão A: {session_a}] ---")
     
-    # Carrega o vector store (RAG)
-    load_vector_store()
+    pergunta1_a = "Olá! O que é polimorfismo em Java? Me explique como se eu fosse um iniciante."
+    print(f"Usuário A: {pergunta1_a}")
+    resposta1_a = chatbot.get_response(session_a, pergunta1_a, "Phi-3 Mini (Microsoft)")
+    print(f"AldoBot:\n{resposta1_a}\n")
+
+    pergunta2_a = "Legal! Pode me dar um exemplo de código sobre isso?"
+    print(f"Usuário A: {pergunta2_a}")
+    resposta2_a = chatbot.get_response(session_a, pergunta2_a, "Phi-3 Mini (Microsoft)")
+    print(f"AldoBot:\n{resposta2_a}\n")
+
+    # --- SIMULAÇÃO DO USUÁRIO B ---
+    session_b = "usuario_beta_002"
+    print(f"\n--- [Sessão B: {session_b}] ---")
     
-    # **NÃO CARREGAMOS MAIS UMA MEMÓRIA GLOBAL AQUI**
-    # A memória será carregada e gerenciada por sessão individualmente
+    pergunta1_b = "Qual a diferença fundamental entre Inteligência Artificial e Machine Learning?"
+    print(f"Usuário B: {pergunta1_b}")
+    resposta1_b = chatbot.get_response(session_b, pergunta1_b, "Phi-3 Mini (Microsoft)")
+    print(f"AldoBot:\n{resposta1_b}\n")
     
-    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()
+    # --- USUÁRIO A CONTINUA ---
+    print(f"\n--- [Sessão A: {session_a} continua] ---")
+    pergunta3_a = "Entendi o exemplo. Esse conceito se aplica em outras linguagens como C++?"
+    print(f"Usuário A: {pergunta3_a}")
+    resposta3_a = chatbot.get_response(session_a, pergunta3_a, "Phi-3 Mini (Microsoft)")
+    print(f"AldoBot:\n{resposta3_a}\n")
+
+    # --- VERIFICANDO A MEMÓRIA ---
+    # A memória do Usuário B não deve ter nenhuma informação sobre Java
+    print("\n--- Verificando estado da memória ---")
+    memoria_a = session_manager.get_session(session_a)
+    memoria_b = session_manager.get_session(session_b)
     
-    # Exemplo de uso para testar com sessões diferentes:
-    print("\n--- Testando sessões independentes ---")
+    print(f"Tamanho da conversa de A: {len(memoria_a['conversation'])} mensagens.")
+    print(f"Nível detectado para A: {memoria_a['user_profile']['nivel']}")
     
-    # 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))
+    print(f"Tamanho da conversa de B: {len(memoria_b['conversation'])} mensagens.")
+    print(f"Nível detectado para B: {memoria_b['user_profile']['nivel']}")
+
+    # --- LIMPANDO UMA SESSÃO ---
+    print(session_manager.clear_memory(session_b))
+    try:
+        session_manager.get_session(session_b)
+    except Exception as e:
+        print(f"Tentativa de acessar sessão B limpa resultou em: {e}")