Update app.py

app.py

@@ -1,437 +1,40 @@
-import requests
-import os
-import json
-import re
-import gradio as gr
-from typing import Dict, Any, List, Optional, Tuple # Importando Tuple
-import pickle
-
-# --- 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")
-
-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",
-}
-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() -> Tuple[str, Optional[str], Optional[str]]: # Alterado o tipo de retorno para incluir os dois caminhos
-    """
-    Função principal do RAG: raspa o blog, cria chunks, gera embeddings e salva o vector store.
-    Esta é a nossa função de "treino".
-    Retorna uma tupla (mensagem_status, caminho_do_arquivo_faiss_para_download, caminho_do_arquivo_urls_para_download).
-    """
-    global vector_store
-    start_time = time.time()
-
-    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.", None, None # Retorna None para os arquivos se não houver conteúdo
-
-    # 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()
-    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 # Retorna a mensagem e os caminhos dos dois arquivos para download
-
-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
-        # Modificado para ignorar o retorno dos caminhos dos arquivos ao carregar
-        message, _, _ = build_and_save_vector_store()
-        print(message) # Imprime a mensagem de status do treino inicial
-
-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
-        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)
-
-# ==============================================================================
-# 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
-    
-    # Primeiro, substituir < e > por entidades HTML para evitar interpretação como tags
-    resposta = resposta.replace('<', '&lt;').replace('>', '&gt;')    
-    resposta_formatada = re.sub(
-        r'```(\w+)?\n(.*?)\n```',
-        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(pergunta: str, modelo_escolhido: str = DEFAULT_MODEL) -> str:
-    """Função principal para gerar respostas, agora com RAG."""
-    if not pergunta.strip():
-        return "Por favor, faça uma pergunta."
-
-    try:
-        # --- ETAPA DE RAG ---
-        print(f"Buscando contexto para a pergunta: '{pergunta[:50]}...'")
-        contexto_blog = retrieve_context_from_blog(pergunta)
-        
-        # Montar o prompt do sistema com o contexto do RAG
-        system_prompt = (
-            "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. "
-            "Responda com clareza, profundidade e tom acadêmico. Foque em explicar e não em só mostrar o resultado. "
-            "Responda sempre em português brasileiro. Use blocos de código formatados com ```. "
-            "Não responda se a pergunta não for sobre o universo de programação e tecnologia."
-            "Nem sempre fornecer código, mas quando tiver código, sempre explique utilizando comentários, o aluno precisa aprender lendo os comentários."
-            "Quando for pergunta sobre disciplinas, foque no conteúdo do blog."
-        )
-        
-        # Montar prompt do usuário, injetando o contexto do blog
-        if contexto_blog:
-            pergunta_completa = (
-                "Você é o professor Dr. Aldo Henrique, especialista em C, Java, desenvolvimento web e inteligência artificial. "
-                "Com base no seguinte contexto extraído do seu blog, responda à pergunta do usuário.\n\n"
-                "--- CONTEXTO DO BLOG ---\n"
-                f"{contexto_blog}\n"
-                "--- FIM DO CONTEXTO ---\n\n"
-                f"PERGUNTA DO USUÁRIO: {pergunta}"
-            "Responda sempre em português brasileiro. Use blocos de código formatados com ```. "
-            "Não responda nada se a pergunta não for sobre o universo de programação e tecnologia."
-            "Nem sempre fornecer código, mas quando tiver código, sempre explique utilizando comentários, o aluno precisa aprender lendo os comentários."
-            "Quando for pergunta sobre disciplinas, foque no conteúdo do blog."
-            )
-            print("Contexto encontrado e injetado no prompt.")
-        else:
-            pergunta_completa = f"{pergunta} Não responda nada se a pergunta não for sobre o universo de programação e tecnologia, informe que o Dr. Aldo Henrique só tem domínio em TI. Você é o Professor Dr. Aldo Henrique, foque em explicar e não em só mostrar o resultado. Quando apresentar código, use blocos de código formatados com ```. Sempre responda primeiro a explicação e depois modestre o código."
-            print("Nenhum contexto relevante encontrado no blog, usando prompt padrão.")
-
-        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: ", "")
-            
-        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:
-    try:
-        url = f"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)
-
-# CSS (inalterado)
-css_customizado = """
-.gradio-container { max-width: 1400px !important; margin: 0 auto; width: 99%; }
-.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; }
+#!/usr/bin/env python3
+"""
+Dr. Aldo Henrique - Chatbot com RAG
+Arquivo principal que inicializa o sistema
 """
 
-# Interface Gradio
-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 - Foco em TI com diferentes modelos de IA </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():
-        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", 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")
-
-        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")
-
-    # --- 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")
-        # Novos componentes para download
-        download_faiss_file = gr.File(label="Download do Índice FAISS", interactive=False, file_count="single", file_types=[".pkl"])
-        download_urls_file = gr.File(label="Download das URLs Processadas", interactive=False, file_count="single", file_types=[".pkl"])
+import os
+from ai_logic import load_vector_store, HF_TOKEN
+from interface import configurar_interface
 
-    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],
-                ["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]
-        )
+def main():
+    """Função principal que inicializa o sistema"""
+    print("🚀 Iniciando Dr. Aldo Henrique com RAG...")
     
-    with gr.Accordion("🔧 Status da API", open=False):
-        status_api = gr.Textbox(label="Status dos Modelos", interactive=False, lines=8)
+    # Verificar se o token HF está configurado
+    if not HF_TOKEN:
+        print("❌ Erro: Token HF_TOKEN não encontrado nas variáveis de ambiente")
+        return
     
-    with gr.Accordion("ℹ️ Informações", open=False):
-        gr.Markdown("""
-        ### Sobre o Dr. Aldo Henrique:
-        - **Especialidade**: Linguagens C, Java, Desenvolvimento Web, Inteligência Artificial
-        - **Conhecimento Adicional**: Conteúdo do blog aldohenrique.com.br
-        ### Dicas para melhores respostas:
-        - 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)
-    # Atualiza o evento para a função build_and_save_vector_store
-    # Agora, ela retorna três valores: a mensagem de status e os caminhos dos dois arquivos
-    botao_retreinar.click(
-        fn=build_and_save_vector_store,
-        outputs=[status_rag, download_faiss_file, download_urls_file], # Saídas atualizadas
-        show_progress=True
-    )
-
-# Lançar aplicação
-if __name__ == "__main__":
-    print("🚀 Iniciando Dr. Aldo Henrique com RAG...")
+    print(f"🔑 Token HF encontrado: {HF_TOKEN[:8]}...")
     
     # Carrega ou constrói o vector store na inicialização
     load_vector_store()
     
-    print(f"🔑 Token HF encontrado: {HF_TOKEN[:8]}...")
+    # Configurar a interface
+    interface = configurar_interface()
+    
     print("🌐 Interface pronta!")
     
+    # Lançar a aplicação
     interface.launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
         max_threads=8,
         show_error=True
-    )
+    )
+
+if __name__ == "__main__":
+    main()