Create app.py

app.py

@@ -0,0 +1,311 @@
+import os
+import sqlite3
+import pandas as pd
+from dotenv import load_dotenv
+from bs4 import BeautifulSoup
+import requests
+import gradio as gr
+import traceback # Para melhor formatação de erros
+import tempfile # Para lidar com arquivos enviados
+
+# Importações LangChain específicas
+from langchain_community.document_loaders import WebBaseLoader, PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_openai import ChatOpenAI
+from langchain.chains import ConversationalRetrievalChain
+from langchain.memory import ConversationBufferMemory
+
+# --- Configuração Inicial ---
+# Carrega chave da API (ajuste conforme sua necessidade)
+load_dotenv()
+# Certifique-se que as variáveis de ambiente estão corretas!
+# Exemplo genérico, use as suas variáveis:
+# os.environ["OPENAI_API_KEY"] = os.getenv("OPENROUTER_API_KEY") # Ou OPENAI_API_KEY
+# os.environ["OPENAI_API_BASE"] = os.getenv("OPENROUTER_API_BASE") # Ou omita se usar OpenAI direto
+
+# Verifique se a chave API está carregada (adicione um check)
+api_key = os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENAI_API_KEY")
+if not api_key:
+    print("⚠️ Atenção: Nenhuma chave de API encontrada nas variáveis de ambiente (OPENROUTER_API_KEY ou OPENAI_API_KEY).")
+    # Você pode querer parar a execução aqui ou usar um modelo local se configurado.
+    # exit() # Descomente para parar se a API for essencial
+
+# Use as variáveis corretas para seu endpoint (OpenRouter ou OpenAI)
+openai_api_key = os.getenv("OPENROUTER_API_KEY") # Ou os.getenv("OPENAI_API_KEY")
+openai_api_base = os.getenv("OPENROUTER_API_BASE") # Opcional, remova se usar OpenAI direto
+
+# Embeddings (modelo local, não requer API)
+print("Carregando modelo de embeddings (pode levar um tempo)...")
+embeddings_model_name = "all-MiniLM-L6-v2"
+try:
+    embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
+    print(f"Modelo de embeddings '{embeddings_model_name}' carregado.")
+except Exception as e:
+    print(f"❌ Erro ao carregar embeddings: {e}")
+    print("Verifique sua conexão com a internet ou se o modelo está disponível.")
+    embeddings = None # Define como None para checagem posterior
+
+# LLM (ajuste o modelo conforme disponibilidade/preferência)
+# Use um modelo disponível no seu endpoint (OpenRouter ou OpenAI)
+# Ex: "gpt-3.5-turbo", "deepseek/deepseek-r1:free", etc.
+llm_model_name = "deepseek/deepseek-r1:free" # Exemplo OpenRouter - TROQUE SE NECESSÁRIO
+try:
+    llm = ChatOpenAI(
+        model=llm_model_name,
+        temperature=0.5,
+        openai_api_key=openai_api_key,
+        base_url=openai_api_base # Passe None se estiver usando OpenAI diretamente
+    )
+    print(f"LLM '{llm_model_name}' configurado.")
+except Exception as e:
+    print(f"❌ Erro ao configurar LLM: {e}")
+    llm = None # Define como None para checagem posterior
+
+# Memória da conversa (pode ser global)
+memoria = ConversationBufferMemory(memory_key="chat_history", return_messages=True, output_key="answer")
+
+# --- Banco de Dados ---
+DB_FILE = "historico_conversas_multidoc.db"
+
+def inicializar_db():
+    conn = sqlite3.connect(DB_FILE)
+    cursor = conn.cursor()
+    cursor.execute('''
+    CREATE TABLE IF NOT EXISTS conversas (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        aluno TEXT,
+        documento TEXT, -- Nova coluna
+        pergunta TEXT,
+        resposta TEXT,
+        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+    ''')
+    conn.commit()
+    conn.close()
+    print(f"Banco de dados '{DB_FILE}' inicializado/verificado.")
+
+inicializar_db() # Garante que a DB exista ao iniciar
+
+def salvar_conversa(nome, documento, pergunta, resposta):
+    if not documento:
+        documento = "Nenhum Documento Carregado"
+    try:
+        conn = sqlite3.connect(DB_FILE)
+        cursor = conn.cursor()
+        cursor.execute("INSERT INTO conversas (aluno, documento, pergunta, resposta) VALUES (?, ?, ?, ?)",
+                       (nome or "Anônimo", documento, pergunta, resposta))
+        conn.commit()
+        conn.close()
+    except Exception as e:
+        print(f"❌ Erro ao salvar conversa no DB: {e}")
+        # Não retorna o erro para a interface, apenas loga no console
+
+# --- Funções Principais ---
+
+def processar_documento(arquivo_pdf, url, progress=gr.Progress(track_tqdm=True)):
+    """Carrega, divide e cria o vector store para um PDF ou URL."""
+    if not embeddings or not llm:
+         return None, None, "❌ Erro: Embeddings ou LLM não foram carregados corretamente. Verifique o console.", ""
+
+    docs = []
+    documento_nome = None
+    temp_dir = None # Para limpar arquivos temporários
+
+    progress(0, desc="Iniciando...")
+    try:
+        if arquivo_pdf is not None:
+            documento_nome = os.path.basename(arquivo_pdf.name)
+            progress(0.1, desc=f"Carregando PDF: {documento_nome}")
+            # Gradio fornece um objeto de arquivo temporário.
+            # PyPDFLoader precisa do caminho do arquivo.
+            loader = PyPDFLoader(arquivo_pdf.name)
+            docs = loader.load()
+            print(f"PDF '{documento_nome}' carregado, {len(docs)} páginas.")
+
+        elif url and url.strip():
+            documento_nome = url.strip()
+            progress(0.1, desc=f"Carregando URL: {documento_nome}")
+            loader = WebBaseLoader(documento_nome)
+            docs = loader.load()
+            print(f"URL '{documento_nome}' carregada, {len(docs)} documentos (partes).")
+
+        else:
+            return None, None, "⚠️ Por favor, forneça um arquivo PDF ou uma URL.", ""
+
+        if not docs:
+             return None, None, f"❌ Erro: Não foi possível extrair conteúdo de '{documento_nome}'.", documento_nome
+
+        progress(0.4, desc="Dividindo documento...")
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+        documents = text_splitter.split_documents(docs)
+        print(f"Documento dividido em {len(documents)} chunks.")
+
+        if not documents:
+            return None, None, "❌ Erro: Documento vazio após divisão.", documento_nome
+
+        progress(0.6, desc="Criando embeddings e vector store (pode levar tempo)...")
+        vectordb = FAISS.from_documents(documents, embeddings)
+        retriever = vectordb.as_retriever()
+        print("Vector store FAISS criado.")
+
+        progress(0.9, desc="Limpando memória da conversa anterior...")
+        memoria.clear() # Limpa o histórico ao carregar novo doc
+        print("Memória da conversa resetada.")
+
+        progress(1, desc="Documento processado!")
+        status = f"✅ Documento '{documento_nome}' carregado e pronto para consulta."
+        return retriever, documento_nome, status, "" # Limpa campo de pergunta
+
+    except Exception as e:
+        print(f"❌ Erro detalhado no processamento: {traceback.format_exc()}")
+        return None, None, f"❌ Erro ao processar o documento: {e}", ""
+    finally:
+        # Limpeza do arquivo temporário do Gradio (se aplicável)
+        # O Gradio geralmente cuida disso, mas podemos garantir
+        if arquivo_pdf is not None and hasattr(arquivo_pdf, 'name') and os.path.exists(arquivo_pdf.name):
+             # Não deletar aqui diretamente, Gradio pode precisar dele.
+             # Apenas certifique-se de que não há vazamento se o Gradio falhar.
+             pass
+
+
+def responder(pergunta, nome_aluno, state_retriever, state_doc_nome):
+    """Responde a pergunta usando o RAG com o documento carregado."""
+    if not state_retriever:
+        return "⚠️ Por favor, carregue um documento (PDF ou URL) primeiro usando o botão 'Carregar Documento'."
+    if not pergunta or not pergunta.strip():
+        return "⚠️ Por favor, digite sua pergunta."
+    if not llm:
+        return "❌ Erro: LLM não está configurado corretamente."
+
+    print(f"\nRecebida pergunta sobre '{state_doc_nome}': {pergunta}")
+
+    try:
+        # Cria a cadeia DENTRO da função para usar o retriever do estado atual
+        qa_chain = ConversationalRetrievalChain.from_llm(
+            llm=llm,
+            retriever=state_retriever,
+            memory=memoria,
+            return_source_documents=True, # Pode ser útil para debug
+            output_key="answer" # Garante que a chave de saída seja 'answer'
+        )
+
+        # Invoca a cadeia
+        resultado = qa_chain.invoke({"question": pergunta})
+        resposta_bruta = resultado.get("answer", "Desculpe, não consegui gerar uma resposta.")
+        fontes = resultado.get("source_documents", []) # Pega as fontes se houver
+
+        # LangChain pode retornar objetos AIMessage, extrai o conteúdo se necessário
+        resposta = resposta_bruta.content if hasattr(resposta_bruta, "content") else str(resposta_bruta)
+
+        print(f"Resposta gerada: {resposta}")
+        if fontes:
+            print(f"Fontes encontradas: {len(fontes)} chunks.")
+            # print("Exemplo de fonte:", fontes[0].page_content[:200]) # Para debug
+
+        # Salva no banco de dados
+        salvar_conversa(nome_aluno, state_doc_nome, pergunta, resposta)
+
+        return resposta
+
+    except Exception as e:
+        print(f"❌ Erro detalhado ao responder: {traceback.format_exc()}")
+        # Retorna erro formatado para a interface
+        return f"❌ **Erro ao gerar resposta:**\n```\n{traceback.format_exc()}\n```"
+
+
+def resetar_memoria_app():
+    """Reseta a memória da conversa."""
+    memoria.clear()
+    print("Memória resetada manualmente.")
+    return "✅ Memória da conversa atual resetada!"
+
+def exportar_conversas():
+    """Exporta o histórico de conversas para CSV e Excel."""
+    try:
+        conn = sqlite3.connect(DB_FILE)
+        # Ordena pelas mais recentes primeiro e seleciona todas as colunas
+        df = pd.read_sql_query("SELECT id, timestamp, aluno, documento, pergunta, resposta FROM conversas ORDER BY timestamp DESC", conn)
+        csv_file = "conversas_exportadas.csv"
+        excel_file = "conversas_exportadas.xlsx"
+        df.to_csv(csv_file, index=False, encoding='utf-8') # Especifica encoding
+        df.to_excel(excel_file, index=False, engine="openpyxl")
+        conn.close()
+        print(f"Histórico exportado para '{csv_file}' e '{excel_file}'.")
+        return f"✅ Histórico exportado para '{csv_file}' e '{excel_file}'!"
+    except Exception as e:
+        print(f"❌ Erro ao exportar histórico: {e}")
+        return f"❌ Erro ao exportar histórico: {e}"
+
+# --- Interface Gradio ---
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🧠 Tutor Multidisciplinar / Analista de Documentos Genérico 📄")
+    gr.Markdown("Faça upload de um PDF ou insira uma URL para começar a conversar sobre o conteúdo.")
+
+    # Estado para manter o retriever e o nome do documento atual
+    state_retriever = gr.State(None)
+    state_doc_nome = gr.State(None)
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            pdf_upload = gr.File(label="Upload de PDF", file_types=[".pdf"])
+            url_input = gr.Textbox(label="Ou Insira a URL do Documento")
+            btn_carregar = gr.Button("🚀 Carregar Documento", variant="primary")
+            status_carregamento = gr.Markdown("") # Para mensagens de status do carregamento
+
+        with gr.Column(scale=2):
+            chatbot_display = gr.Textbox(label="Resposta do Assistente", lines=15, interactive=False) # Usar Textbox para formatar melhor erros
+            nome_aluno = gr.Textbox(label="Seu nome (opcional)", placeholder="Ex: Maria")
+            pergunta_input = gr.Textbox(label="Sua Pergunta sobre o Documento Carregado", placeholder="Faça sua pergunta aqui...")
+            with gr.Row():
+                 btn_enviar = gr.Button("✉️ Enviar Pergunta", variant="primary")
+                 btn_resetar = gr.Button("🔁 Resetar Memória")
+                 btn_exportar = gr.Button("📤 Exportar Histórico")
+
+    # --- Conexões da Interface ---
+
+    # Botão Carregar Documento
+    btn_carregar.click(
+        fn=processar_documento,
+        inputs=[pdf_upload, url_input],
+        outputs=[state_retriever, state_doc_nome, status_carregamento, pergunta_input] # Limpa pergunta ao carregar
+    )
+
+    # Botão Enviar Pergunta
+    btn_enviar.click(
+        fn=responder,
+        inputs=[pergunta_input, nome_aluno, state_retriever, state_doc_nome],
+        outputs=chatbot_display
+    ).then(lambda: "", outputs=pergunta_input) # Limpa o campo de pergunta após enviar
+
+    # Botão Resetar Memória
+    btn_resetar.click(
+        fn=resetar_memoria_app,
+        outputs=chatbot_display # Mostra mensagem de reset na caixa de resposta
+    )
+
+    # Botão Exportar Histórico
+    btn_exportar.click(
+        fn=exportar_conversas,
+        outputs=chatbot_display # Mostra mensagem de exportação na caixa de resposta
+    )
+
+    # Limpar campos de input ao usar o outro (PDF vs URL)
+    def limpar_outro_input(input_data):
+        # Se o input veio do upload (não é None), retorna None para o textbox da URL
+        if input_data is not None:
+            return None
+        return gr.update() # Não muda nada se o input veio do textbox
+
+    pdf_upload.change(fn=limpar_outro_input, inputs=pdf_upload, outputs=url_input)
+    url_input.change(fn=limpar_outro_input, inputs=url_input, outputs=pdf_upload)
+
+
+# --- Lançar a Aplicação ---
+if __name__ == "__main__":
+    if embeddings and llm: # Só lança se componentes essenciais carregaram
+        print("Iniciando interface Gradio...")
+        app.launch(share=True, debug=True) # Share=True para link público, Debug=True para mais logs
+    else:
+        print("❌ Aplicação não iniciada devido a falha no carregamento de Embeddings ou LLM.")