Update app.py

app.py

@@ -3,25 +3,161 @@ import os
 import json
 import re
 import gradio as gr
-from typing import Dict, Any
+from typing import Dict, Any, List, Optional
+import pickle
 
-# Configuração da API
+# --- Novas importações para o RAG ---
+import time
+from bs4 import BeautifulSoup
+from urllib.parse import urljoin, urlparse
+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"
+
+# --- 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 via API (testados e funcionais)
 MODELS = {
     "Phi-3 Mini (Microsoft)": "microsoft/Phi-3-mini-4k-instruct",
     "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
     "Zephyr 7B": "HuggingFaceH4/zephyr-7b-beta",
-    "Llama 3.2 3B (Meta)": "meta-llama/Llama-3.2-3B-Instruct", 
-    "DeepSeek-Coder-V2": "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",  # Replaced DeepSeek-Code
+    "Llama 3.2 3B (Meta)": "meta-llama/Llama-3.2-3B-Instruct",
+    "DeepSeek-Coder-V2": "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct",
 }
-
-# Modelo padrão (mais confiável)
 DEFAULT_MODEL = "Phi-3 Mini (Microsoft)"
 
+# --- Variáveis Globais para o RAG ---
+vector_store: Optional[FAISS] = None
+
+# ==============================================================================
+# SEÇÃO RAG: FUNÇÕES PARA CRAWLING, EMBEDDING E ARMAZENAMENTO
+# ==============================================================================
+
+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)
+                # Garante que estamos no mesmo domínio e não é um link de âncora
+                if urlparse(full_url).netloc == urlparse(url).netloc and full_url not in visited_links:
+                    links_to_visit.add(full_url)
+        except requests.RequestException as e:
+            print(f"Erro ao acessar {current_url}: {e}")
+
+    # Filtra apenas as páginas que parecem ser posts ou páginas de conteúdo
+    final_links = {link for link in visited_links if '/tag/' not in link and '/category/' not in link and '?' not in link}
+    return final_links
+
+
+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')
+        # Tenta encontrar a tag <article> ou <main> que geralmente contém o conteúdo principal
+        main_content = soup.find('article') or soup.find('main')
+        if main_content:
+            return main_content.get_text(separator='\n', strip=True)
+        return ""
+    except Exception as e:
+        print(f"Erro ao raspar {url}: {e}")
+        return ""
+
+def build_and_save_vector_store() -> str:
+    """
+    Função principal do RAG: raspa o blog, cria chunks, gera embeddings e salva o vector store.
+    Esta é a nossa função de "treino".
+    """
+    global vector_store
+    start_time = time.time()
+
+    print("Iniciando o processo de retreino do RAG...")
+    processed_urls = set()
+
+    # 1. Obter todos os links do blog
+    all_links = get_all_blog_links(BLOG_URL, processed_urls)
+    print(f"Encontrados {len(all_links)} links para processar.")
+
+    # 2. Raspar o texto de cada link
+    all_texts = [scrape_text_from_url(link) for link in all_links if link not in processed_urls]
+    all_texts = [text for text in all_texts if text] # Remove textos vazios
+    print(f"Textos extraídos de {len(all_texts)} novas páginas.")
+
+    if not all_texts:
+        return "Nenhum novo conteúdo encontrado para treinar."
+
+    # 3. Dividir os textos em chunks
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+    chunks = text_splitter.create_documents(all_texts)
+    print(f"Textos divididos em {len(chunks)} chunks.")
+
+    # 4. Criar embeddings e o vector store (FAISS)
+    print("Carregando modelo de embedding...")
+    embeddings_model = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+    print("Criando o vector store com FAISS...")
+    vector_store = FAISS.from_documents(chunks, embeddings_model)
+
+    # 5. Salvar o vector store e as URLs processadas em disco
+    with open(VECTOR_STORE_PATH, "wb") as f:
+        pickle.dump(vector_store, f)
+
+    with open(PROCESSED_URLS_PATH, "wb") as f:
+        pickle.dump(all_links, f)
+
+    end_time = time.time()
+    return f"✅ Retreino do RAG concluído em {end_time - start_time:.2f} segundos. {len(chunks)} chunks de texto processados."
+
+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.")
+        # Inicia o treino automaticamente se não houver um índice
+        build_and_save_vector_store()
+
+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
+# ==============================================================================
+
 class HuggingFaceAPIClient:
     def __init__(self, token: str):
         self.token = token
@@ -29,11 +165,10 @@ class HuggingFaceAPIClient:
             "Authorization": f"Bearer {token}",
             "Content-Type": "application/json"
         }
-    
-    def query_model(self, model_name: str, messages: list, max_tokens: int = 500) -> str:
+
+    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,
@@ -42,363 +177,233 @@ class HuggingFaceAPIClient:
             "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:
-                # Fallback para API de texto simples se a API de chat não funcionar
                 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:
-        """Fallback usando API de geração de texto simples"""
         url = f"https://api-inference.huggingface.co/models/{model_name}"
-        
-        # Converte mensagens para prompt simples
         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
+                "max_new_tokens": max_tokens, "temperature": 0.7, "top_p": 0.9,
+                "do_sample": True, "return_full_text": False
             },
-            "options": {
-                "wait_for_model": True,  # Espera modelo carregar
-                "use_cache": 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", "")
-                    # Limpa o texto gerado
                     if generated_text:
-                        # Remove o prompt original da resposta
                         if "Assistente: " in generated_text:
                             parts = generated_text.split("Assistente: ")
-                            if len(parts) > 1:
-                                return parts[-1].strip()
+                            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()
+                    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. Tente outro modelo."
-            elif response.status_code == 503:
-                return "⏳ Modelo carregando... Aguarde alguns segundos e tente novamente."
-            elif response.status_code == 429:
-                return "⚠️ Muitas requisições. Aguarde um momento antes de tentar novamente."
-            else:
-                return f"Erro HTTP {response.status_code}: {response.text[:200]}..."
-                
+            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. Tente novamente."
+            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:
-        """Converte mensagens para formato de prompt"""
         prompt = ""
         for msg in messages:
-            if msg["role"] == "system":
-                prompt += f"Sistema: {msg['content']}\n\n"
-            elif msg["role"] == "user":
-                prompt += f"Usuário: {msg['content']}\n\n"
-            elif msg["role"] == "assistant":
-                prompt += f"Assistente: {msg['content']}\n\n"
-        
+            prompt += f"{msg['role'].capitalize()}: {msg['content']}\n\n"
         prompt += "Assistente: "
         return prompt
 
 # Inicializar cliente da API
 api_client = HuggingFaceAPIClient(HF_TOKEN)
 
+# ==============================================================================
+# SEÇÃO PRINCIPAL: LÓGICA DO CHATBOT E GRADIO
+# ==============================================================================
+
 def formatar_resposta_com_codigo(resposta: str) -> str:
-    """Formata a resposta destacando códigos em blocos separados"""
-    if not resposta:
-        return resposta
-    
-    # Detecta blocos de código com ```
+    """Formata a resposta destacando códigos em blocos separados."""
+    if not resposta: return resposta
     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, flags=re.DOTALL
     )
-    
-    # Detecta código inline com `
     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
     )
-    
-    # Adiciona quebras de linha para melhor visualização
-    resposta_formatada = resposta_formatada.replace('\n\n', '<br><br>')
     resposta_formatada = resposta_formatada.replace('\n', '<br>')
-    
-    # Destaca títulos/seções
     resposta_formatada = re.sub(
         r'^\*\*(.*?)\*\*',
         r'<h3 style="color: #1a1a1a; margin-top: 20px; margin-bottom: 10px;">\1</h3>',
-        resposta_formatada,
-        flags=re.MULTILINE
+        resposta_formatada, flags=re.MULTILINE
     )
-    
     return resposta_formatada
 
 def responder_como_aldo(pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) -> str:
-    """Função principal para gerar respostas via API"""
+    """Função principal para gerar respostas, agora com RAG."""
     if not pergunta.strip():
         return "Por favor, faça uma pergunta."
-    
+
     try:
-        # Preparar mensagens
-        pergunta_completa = f"{pergunta} Não responda nada se a pergunta não for sobre o universo de programação e tecnologia, informe que o Dr. Aldo Henrique só tem domínio em TI. Você é o Professor Dr. Aldo Henrique, foque em explicar e não em só mostrar o resultado. Quando apresentar código, use blocos de código formatados com ```. Sempre responda primeiro a explicação e depois modestre o código."
+        # --- ETAPA DE RAG ---
+        print(f"Buscando contexto para a pergunta: '{pergunta[:50]}...'")
+        contexto_blog = retrieve_context_from_blog(pergunta)
+        
+        # Montar o prompt do sistema com o contexto do RAG
+        system_prompt = (
+            "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. "
+            "Responda com clareza, profundidade e tom acadêmico. Foque em explicar e não em só mostrar o resultado. "
+            "Responda sempre em português brasileiro. Use blocos de código formatados com ```. "
+            "Não responda nada se a pergunta não for sobre o universo de programação e tecnologia."
+        )
         
+        # Montar prompt do usuário, injetando o contexto do blog
+        if contexto_blog:
+            pergunta_completa = (
+                "Com base no seguinte contexto extraído do seu blog, responda à pergunta do usuário.\n\n"
+                "--- CONTEXTO DO BLOG ---\n"
+                f"{contexto_blog}\n"
+                "--- FIM DO CONTEXTO ---\n\n"
+                f"PERGUNTA DO USUÁRIO: {pergunta}"
+            )
+            print("Contexto encontrado e injetado no prompt.")
+        else:
+            pergunta_completa = f"{pergunta} Não responda nada se a pergunta não for sobre o universo de programação e tecnologia, informe que o Dr. Aldo Henrique só tem domínio em TI. Você é o Professor Dr. Aldo Henrique, foque em explicar e não em só mostrar o resultado. Quando apresentar código, use blocos de código formatados com ```. Sempre responda primeiro a explicação e depois modestre o código."
+            print("Nenhum contexto relevante encontrado no blog, usando prompt padrão.")
+
         messages = [
-            {
-                "role": "system", 
-                "content": "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. Sempre responda primeiro a explicação e depois modestre o código. Responda com clareza, profundidade e tom acadêmico, como um professor experiente. Evite respostas genéricas e forneça exemplos práticos quando aplicável. Foque em explicar e não em só mostrar o resultado. Responda sempre em português brasileiro. Use blocos de código formatados com ``` quando apresentar código. Não responda nada se a pergunta não for sobre o universo de programação e tecnologia."
-            },
-            {
-                "role": "user", 
-                "content": pergunta_completa
-            }
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": pergunta_completa}
         ]
         
-        # Obter o nome real do modelo
         model_name = MODELS.get(modelo_escolhido, MODELS[DEFAULT_MODEL])
+        resposta = api_client.query_model(model_name, messages)
         
-        # Fazer requisição
-        resposta = api_client.query_model(model_name, messages, max_tokens=800)
-        
-        # Limpar resposta se necessário
         if resposta.startswith("Assistente: "):
             resposta = resposta.replace("Assistente: ", "")
-        
-        # Formatar resposta com código
+            
         resposta_formatada = formatar_resposta_com_codigo(resposta.strip())
-        
         return resposta_formatada
         
     except Exception as e:
         return f"Erro ao processar sua pergunta: {str(e)}"
 
+# Funções de teste (inalteradas)
 def verificar_modelo_disponivel(model_name: str) -> str:
-    """Verifica se um modelo está disponível na API"""
     try:
         url = f"https://api-inference.huggingface.co/models/{model_name}"
         headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        
-        # Teste simples
-        payload = {
-            "inputs": "Hello",
-            "parameters": {"max_new_tokens": 5}
-        }
-        
+        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}"
-            
+        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():
-    """Testa todos os modelos disponíveis"""
     resultados = []
     for nome, modelo in MODELS.items():
         status = verificar_modelo_disponivel(modelo)
         resultados.append(f"{nome}: {status}")
     return "\n".join(resultados)
 
-# CSS customizado para melhor visualização
+# CSS (inalterado)
 css_customizado = """
-.gradio-container {
-    max-width: 1400px !important;
-    margin: 0 auto;
-    width: 85%;
-}
-
-.gr-textbox textarea {
-    font-size: 14px !important;
-    line-height: 1.5 !important;
-}
-
-.resposta-container {
-    background-color: #ffffff !important;
-    color: #1a1a1a !important;
-    border: 1px solid #e0e0e0 !important;
-    border-radius: 20px !important;
-    padding: 20px !important;
-    margin: 20px 0 !important;
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05) !important;
-}
-
-.resposta-container pre code {
-    color: #1a1a1a !important;
-    background-color: #f8f9fa !important;
-}
-
-.pergunta-container {
-    background-color: #f0f8ff !important;
-    border-radius: 8px !important;
-    padding: 15px !important;
-}
-
-.titulo-principal {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
-    color: white !important;
-    padding: 20px !important;
-    border-radius: 10px !important;
-    margin-bottom: 20px !important;
-    text-align: center !important;
-}
-
-.modelo-dropdown {
-    margin-bottom: 15px !important;
-}
+.gradio-container { max-width: 1400px !important; margin: 0 auto; width: 85%; }
+.gr-textbox textarea { font-size: 14px !important; line-height: 1.5 !important; }
+.resposta-container { background-color: #ffffff !important; color: #1a1a1a !important; border: 1px solid #e0e0e0 !important; border-radius: 20px !important; padding: 20px !important; margin: 20px 0 !important; box-shadow: 0 2px 4px rgba(0, 0, 0, 0.05) !important; }
+.resposta-container pre code { color: #1a1a1a !important; background-color: #f8f9fa !important; }
+.pergunta-container { background-color: #f0f8ff !important; border-radius: 8px !important; padding: 15px !important; }
+.titulo-principal { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important; color: white !important; padding: 20px !important; border-radius: 10px !important; margin-bottom: 20px !important; text-align: center !important; }
+.modelo-dropdown { margin-bottom: 15px !important; }
 """
 
 # Interface Gradio
-with gr.Blocks(
-    title="Dr. Aldo Henrique - API Externa", 
-    theme=gr.themes.Soft(), 
-    css=css_customizado
-) as interface:
-    
-    # Cabeçalho estilizado
+with gr.Blocks(title="Dr. Aldo Henrique - API Externa", theme=gr.themes.Soft(), css=css_customizado) as interface:
     gr.HTML("""
     <div class="titulo-principal">
-        <h1>🤖 Dr. Aldo Henrique - Especialista em TI</h1>
-        <p style="font-size: 14px; opacity: 0.9;">Dúvidas sobre C, Java, desenvolvimento web, IA e muito mais!</p>
+        <h1>🤖 Dr. Aldo Henrique - Especialista em TI (com RAG)</h1>
+        <p style="font-size: 14px; opacity: 0.9;">Conhecimento enriquecido com o conteúdo do <a href="https://aldohenrique.com.br/" style="color: white; text-decoration: underline;">Blog do Prof. Dr. Aldo Henrique</a></p>
     </div>
     """)
     
     with gr.Row():
-        # Coluna da esquerda - Entrada
         with gr.Column(scale=2):
             gr.Markdown("### 📝 Faça sua pergunta:")
-            entrada = gr.Textbox(
-                label="", 
-                placeholder="Digite sua pergunta aqui.", 
-                lines=6,
-                elem_classes="pergunta-container"
-            )
-            
-            modelo_select = gr.Dropdown(
-                choices=list(MODELS.keys()),
-                value=DEFAULT_MODEL,
-                label="🧠 Selecione o Modelo de IA",
-                info="Escolha o modelo para responder sua pergunta",
-                elem_classes="modelo-dropdown"
-            )
+            entrada = gr.Textbox(label="", placeholder="Digite sua pergunta aqui.", lines=6, elem_classes="pergunta-container")
+            modelo_select = gr.Dropdown(choices=list(MODELS.keys()), value=DEFAULT_MODEL, label="🧠 Selecione o Modelo de IA", info="Escolha o modelo para responder", elem_classes="modelo-dropdown")
             
             with gr.Row():
-                botao_perguntar = gr.Button(
-                    "🤔 Perguntar ao Dr. Aldo", 
-                    variant="primary", 
-                    size="lg"
-                )
-                botao_testar = gr.Button(
-                    "🔍 Testar Modelos", 
-                    variant="secondary"
-                )
-        
-        # Coluna da direita - Saída
+                botao_perguntar = gr.Button("🤔 Perguntar ao Dr. Aldo", variant="primary", size="lg")
+                botao_testar = gr.Button("🔍 Testar Modelos", variant="secondary")
+
         with gr.Column(scale=3):
             gr.Markdown("### 💬 Resposta do Dr. Aldo Henrique:")
-            saida = gr.HTML(
-                label="",
-                value="<div style='padding: 20px; text-align: center; color: #1a1a1a;'>Aguardando sua pergunta...</div>",
-                elem_classes="resposta-container"
-            )
-    
-    # Seção expandida para exemplos
+            saida = gr.HTML(label="", value="<div style='padding: 20px; text-align: center; color: #1a1a1a;'>Aguardando sua pergunta...</div>", elem_classes="resposta-container")
+
+    # --- NOVA SEÇÃO PARA CONTROLE DO RAG ---
+    with gr.Accordion("⚙️ Controle do Conhecimento (RAG)", open=False):
+        status_rag = gr.Textbox(label="Status do Retreino", interactive=False)
+        botao_retreinar = gr.Button("🔄 Atualizar Conhecimento do Blog", variant="stop")
+
     with gr.Accordion("📚 Exemplos de Perguntas", open=False):
         gr.Examples(
             examples=[
                 ["Como implementar uma lista ligada em C com todas as operações básicas?", DEFAULT_MODEL],
-                ["Explique a diferença entre == e equals() em Java com exemplos práticos", "Mistral 7B"],
-                ["Como funciona o algoritmo de machine learning Random Forest?", "Llama 3.2 3B (Meta)"],
-                ["Mostre como criar uma API REST completa com Spring Boot", "Zephyr 7B"]
+                ["Qual a sua opinião sobre o uso de ponteiros em C++ moderno, baseada no seu blog?", "Mistral 7B"],
+                ["Resuma o que você escreveu sobre machine learning no seu blog.", "Llama 3.2 3B (Meta)"],
             ],
             inputs=[entrada, modelo_select]
         )
     
-    # Status da API (expandível)
     with gr.Accordion("🔧 Status da API", open=False):
-        status_api = gr.Textbox(
-            label="Status dos Modelos", 
-            interactive=False,
-            lines=8
-        )
+        status_api = gr.Textbox(label="Status dos Modelos", interactive=False, lines=8)
     
-    # Informações adicionais
     with gr.Accordion("ℹ️ Informações", open=False):
         gr.Markdown("""
         ### Sobre o Dr. Aldo Henrique:
         - **Especialidade**: Linguagens C, Java, Desenvolvimento Web, Inteligência Artificial
-        - **Foco**: Explicações didáticas e exemplos práticos
-        - **Abordagem**: Acadêmica e profissional
-        
-        ### Modelos Disponíveis:
-        - **Phi-3 Mini**: Modelo compacto e eficiente da Microsoft
-        - **Llama 3.2 3B**: Versão menor do modelo da Meta
-        - **Mistral 7B**: Modelo francês de alta qualidade
-        - **Zephyr 7B**: Versão otimizada para diálogo
-        
+        - **Conhecimento Adicional**: Conteúdo do blog aldohenrique.com.br
         ### Dicas para melhores respostas:
-        - Seja específico em suas perguntas
-        - Mencione o contexto (iniciante, intermediário, avançado)
-        - Peça exemplos práticos quando necessário
+        - Faça perguntas específicas sobre o conteúdo do blog para ver o RAG em ação!
+        - Peça resumos ou opiniões sobre temas que o professor aborda.
         """)
-    
+        
     # Eventos
-    botao_perguntar.click(
-        fn=responder_como_aldo, 
-        inputs=[entrada, modelo_select], 
-        outputs=saida,
-        show_progress=True
-    )
-    
-    botao_testar.click(
-        fn=testar_todos_modelos,
-        outputs=status_api,
-        show_progress=True
-    )
+    botao_perguntar.click(fn=responder_como_aldo, inputs=[entrada, modelo_select], outputs=saida, show_progress=True)
+    botao_testar.click(fn=testar_todos_modelos, outputs=status_api, show_progress=True)
+    botao_retreinar.click(fn=build_and_save_vector_store, outputs=status_rag, show_progress=True)
 
 # Lançar aplicação
 if __name__ == "__main__":
-    print("🚀 Iniciando Dr. Aldo Henrique com Interface Melhorada...")
+    print("🚀 Iniciando Dr. Aldo Henrique com RAG...")
+    
+    # Carrega ou constrói o vector store na inicialização
+    load_vector_store()
+    
     print(f"🔑 Token HF encontrado: {HF_TOKEN[:8]}...")
-    print("🌐 Interface otimizada para melhor visualização!")
-    print("💻 Formatação especial para códigos implementada!")
+    print("🌐 Interface pronta!")
     
     interface.launch(
         server_name="0.0.0.0",