Update app.py

app.py

@@ -1,15 +1,27 @@
 #--- START OF FILE app (23).py ---
 
 import streamlit as st
-from groq import Groq
 import time
+import os # Importado para manipulação de arquivos temporários
+
+# --- IMPORTS GROQ ---
+from groq import Groq
+
+# --- IMPORTS LANGCHAIN / RAG ---
+from langchain_community.document_loaders import TextLoader 
+from langchain_community.document_loaders import PyPDFLoader # Para carregar PDFs
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_huggingface import HuggingFaceEmbeddings # Embeddings que rodam na CPU
+from langchain_community.vectorstores import FAISS
+from langchain.chains import RetrievalQA
+from langchain_groq import ChatGroq 
+# O LangChain precisa de uma chave de API para o modelo de embeddings (se usar OpenAI), 
+# mas o HuggingFaceEmbeddings é local/gratuito.
 
 # 1. Título da Página e Configuração de Layout
-st.set_page_config(page_title="Iza - Assistente Groq", layout="wide")
+st.set_page_config(page_title="Iza - Assistente Groq RAG", layout="wide")
 
 # --- CSS CORRIGIDO E ATUALIZADO (REMOÇÃO DO AVATAR E ESPAÇO) ---
-# Este CSS oculta os avatares (usando seletores mais robustos), remove o espaço 
-# que ocupavam e justifica o texto da conversa.
 st.markdown("""
 <style>
     /* NOVO: Oculta o primeiro filho dentro do container de mensagem (que é o avatar/ícone) */
@@ -54,53 +66,137 @@ st.markdown("""
 </style>
 """, unsafe_allow_html=True)
 
-st.title("Iza - Assistente com Groq 🚀")
-st.caption("Um chatbot com memória, upload de arquivos e controle de velocidade.")
+st.title("Iza - Assistente com Groq RAG 🚀")
+st.caption("Um chatbot com memória, upload de arquivos e controle de velocidade. Integração com LangChain RAG.")
 
-# 2. Barra Lateral para Opções e Upload de Arquivos
+# 3. Configuração do Cliente Groq
+# Cliente Groq padrão para chamadas com Tool Use
+client = Groq()
+# Cliente Groq para uso dentro do LangChain
+groq_llm = ChatGroq(model_name="mixtral-8x7b-32768", temperature=0.7) 
+
+# 2. Barra Lateral e Lógica de Upload/Processamento RAG
 with st.sidebar:
     st.header("Opções")
-    uploaded_file = st.file_uploader("Anexe um arquivo (opcional)", type=None)
+    
+    # Adicionando uma variável de sessão para rastrear o arquivo processado
+    if 'retriever' not in st.session_state:
+        st.session_state.retriever = None
+        st.session_state.retriever_source = None
+        
+    uploaded_file = st.file_uploader("Anexe um arquivo (.txt, .md, .pdf)", type=["txt", "md", "pdf"])
+    
+    # Processamento do Arquivo
     if uploaded_file:
-        st.success(f"Arquivo '{uploaded_file.name}' carregado!")
-        # A lógica para usar o arquivo seria adicionada aqui.
+        # Apenas processa se o arquivo for novo ou o retriever ainda não existir
+        if st.session_state.retriever_source != uploaded_file.name:
+            
+            # 1. SALVAR/LER ARQUIVO TEMPORARIAMENTE
+            bytes_data = uploaded_file.read()
+            # Cria um caminho de arquivo temporário (importa o 'os' para remover depois, se necessário)
+            file_path = f"./temp_file_{uploaded_file.name.replace('/', '_')}"
+            try:
+                with open(file_path, "wb") as f:
+                    f.write(bytes_data)
 
-# 3. Configuração do Cliente Groq
-# Assume que a chave GROQ_API_KEY está configurada no ambiente ou no .streamlit/secrets.toml
-client = Groq()
+                # 2. CONFIGURAÇÃO RAG
+                with st.spinner(f"Processando '{uploaded_file.name}' para pesquisa..."):
+                    
+                    # Carregamento do Documento
+                    if uploaded_file.type == 'application/pdf':
+                        loader = PyPDFLoader(file_path)
+                    elif uploaded_file.type in ['text/markdown', 'text/plain']:
+                        loader = TextLoader(file_path)
+                    else:
+                        st.error("Tipo de arquivo não suportado após o upload.")
+                        st.session_state.retriever = None
+                        st.session_state.retriever_source = None
+                        
+                    documents = loader.load()
+                    
+                    # Fragmentação do Texto
+                    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+                    texts = text_splitter.split_documents(documents)
+                    
+                    # HuggingFace Embeddings (Roda na CPU)
+                    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+                    
+                    # Criar o Vector Store (FAISS)
+                    vectorstore = FAISS.from_documents(texts, embeddings)
+                    
+                    # Criar o Retriever e armazenar na sessão
+                    st.session_state.retriever = vectorstore.as_retriever()
+                    st.session_state.retriever_source = uploaded_file.name
+                    st.success(f"Arquivo '{uploaded_file.name}' processado e pronto para pesquisa!")
+
+            except Exception as e:
+                st.error(f"Erro ao processar o arquivo com LangChain: {e}")
+                st.session_state.retriever = None
+                st.session_state.retriever_source = None
+            finally:
+                # Tenta remover o arquivo temporário
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+        
+        else:
+             # Se o arquivo já foi processado e está na sessão
+             st.success(f"Arquivo '{st.session_state.retriever_source}' carregado e pronto para pesquisa!")
+
+    elif st.session_state.retriever_source is not None:
+         # Limpa se o widget do uploader estiver vazio mas o retriever estiver ativo
+         st.session_state.retriever = None
+         st.session_state.retriever_source = None
 
 # 4. Inicialização do Histórico da Conversa
 if "messages" not in st.session_state:
     system_prompt = (
         "Você é um assistente de pesquisa avançado chamado Iza. "
-        "Sua tarefa é usar as ferramentas 'visit_website' ou 'web_search' para obter informações sobre um site "
-        "e fornecer um resumo completo, bem estruturado e detalhado em markdown. "
+        "Se houver um documento anexo, use-o como primeira fonte de conhecimento. "
+        "Caso contrário, use as ferramentas 'visit_website' ou 'web_search' para obter informações. "
+        "Sua tarefa é fornecer um resumo completo, bem estruturado e detalhado em markdown. "
         "IMPORTANTE: Ao criar tabelas, elas devem ter no máximo 3 colunas, e de preferência apenas 2, "
         "para garantir a legibilidade em todas as telas."
     )
     st.session_state.messages = [{"role": "system", "content": system_prompt}]
 
 # 5. Exibição das Mensagens Anteriores
-# O 'role' é mantido para fins de estrutura, mas o avatar está oculto pelo CSS
 for message in st.session_state.messages:
     if message["role"] != "system":
         with st.chat_message(message["role"]):
             st.markdown(message["content"])
 
 # 6. Lógica de Interação do Chat
-if prompt := st.chat_input("Pergunte algo sobre um site..."):
+if prompt := st.chat_input("Pergunte algo sobre o documento ou faça uma pesquisa na web..."):
     # 6a. Adiciona a mensagem do usuário e exibe
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.markdown(prompt)
 
-    # 6b. Obtém a resposta do assistente (Streaming)
+    # 6b. Obtém a resposta do assistente (RAG ou Streaming com Tool Use)
     with st.chat_message("assistant"):
+        placeholder = st.empty()
+        full_response = ""
+
         try:
-            def stream_groq_response():
-                # Chama a API Groq com o histórico completo
+            # --- LÓGICA DE DECISÃO RAG vs GROQ DIRETO ---
+            if st.session_state.retriever is not None:
+                # RAG: Caso haja um arquivo anexado.
+                qa_chain = RetrievalQA.from_chain_type(
+                    llm=groq_llm,
+                    chain_type="stuff",
+                    retriever=st.session_state.retriever,
+                    return_source_documents=False # Opcional: mude para True para ver as fontes
+                )
+                
+                # OBS: A resposta RAG geralmente não faz streaming de forma simples.
+                with st.spinner("Buscando no documento e gerando resposta..."):
+                    result = qa_chain.invoke({"query": prompt})
+                    full_response = result['result']
+                
+            else:
+                # GROQ DIRETO: Caso NÃO haja arquivo (usa Tool Use para pesquisa web).
                 stream = client.chat.completions.create(
-                    model="groq/compound",
+                    model="groq/compound", # Modelo com Compound para Tool Use
                     messages=[
                         {"role": m["role"], "content": m["content"]}
                         for m in st.session_state.messages
@@ -110,23 +206,20 @@ if prompt := st.chat_input("Pergunte algo sobre um site..."):
                     stream=True,
                     compound_custom={"tools": {"enabled_tools": ["web_search", "visit_website"]}}
                 )
+                
+                # Streaming da resposta
                 for chunk in stream:
-                    yield chunk.choices[0].delta.content or ""
-            
-            placeholder = st.empty()
-            full_response = ""
-            for token in stream_groq_response():
-                full_response += token
-                # Exibe a resposta com um cursor de digitação '▌'
-                placeholder.markdown(full_response + "▌")
-                # Atraso mínimo para o efeito de digitação (opcional)
-                time.sleep(0.005) 
+                    full_response += chunk.choices[0].delta.content or ""
+                    placeholder.markdown(full_response + "▌")
+                    time.sleep(0.005)
+
+            # Exibe a resposta completa (do RAG ou do Streaming)
             placeholder.markdown(full_response)
             
             # 6c. Adiciona a resposta completa ao histórico
             st.session_state.messages.append({"role": "assistant", "content": full_response})
 
         except Exception as e:
-            st.error(f"Ocorreu um erro ao contatar a API da Groq: {e}")
+            st.error(f"Ocorreu um erro na interação: {e}")
 
 # --- END OF FILE app (23).py ---