Upload 19 files

.env

@@ -0,0 +1,8 @@
+OPENAI_API_KEY=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
+LANGSMITH_API_KEY=
+PINECONE_API_KEY=pcsk_6MNEad_PUMZQykNTtjE6qmCYJicbJMFkqrRHa5UgtGZKNEjwrEjqcQ5uAmqDGb7fH8ThQu
+
+
+SUPABASE_URL=https://pjfwwtllcdoapscfehoc.supabase.co
+SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBqZnd3dGxsY2RvYXBzY2ZlaG9jIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MzkxMjEzMTUsImV4cCI6MjA1NDY5NzMxNX0.b1PsWNXHKusgVWHMzyEvTV-XuddUu2BEmuMmJ9BMPNE
+SUPABASE_SERVICE_ROLE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBqZnd3dGxsY2RvYXBzY2ZlaG9jIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTczOTEyMTMxNSwiZXhwIjoyMDU0Njk3MzE1fQ.g1ie61hA73q1wjGdaqCZJzfkMYl8450SWI58umqjmhs

main.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from oauth.login import main as login_main
+from oauth.cadastro import main as cadastro_main
+from sollai.chat import main as chat_main
+
+# Configuração inicial do Streamlit
+st.set_page_config(
+    page_title="Sollai Assistant",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Inicializar variáveis de sessão
+if 'is_authenticated' not in st.session_state:
+    st.session_state['is_authenticated'] = False
+
+if 'user' not in st.session_state:
+    st.session_state['user'] = None
+
+if 'assistant' not in st.session_state:
+    st.session_state['assistant'] = None
+
+# Função principal
+def main():
+    if not st.session_state['is_authenticated']:
+        login_main()
+    else:
+        user = st.session_state['user']
+        assistant = st.session_state.get('assistant')
+        
+        if not assistant:
+            st.warning("⚠️ Você não possui um assistente configurado.")
+            if st.button("Sair"):
+                for key in st.session_state.keys():
+                    del st.session_state[key]
+                st.rerun()
+        else:
+            chat_main()
+
+# Execução principal
+if __name__ == "__main__":
+    main()

oauth/__init__.py

@@ -0,0 +1 @@
+# Arquivo vazio para marcar o diretório como um pacote Python 

oauth/cadastro.py

@@ -0,0 +1,250 @@
+import sys
+from pathlib import Path
+
+# Adicionar o diretório raiz ao PYTHONPATH
+root_dir = Path(__file__).parent.parent
+sys.path.append(str(root_dir))
+
+import streamlit as st
+import pandas as pd
+from oauth.user_manager import UserManager
+from oauth.supabase_conex import SupabaseConnection
+from datetime import datetime
+from sollai.assistentes import CriaAssistente, AssistenteConfig
+
+def create_admin_user(email: str, password: str, nome: str, is_admin: bool = False):
+    """Cria um novo usuário diretamente"""
+    try:
+        # Usar admin client para ter permissões totais
+        admin_client = SupabaseConnection().get_admin_client()
+        
+        # 1. Criar usuário na auth
+        auth_response = admin_client.auth.admin.create_user({
+            "email": email,
+            "password": password,
+            "email_confirm": True,
+            "user_metadata": {
+                "nome": nome,
+                "is_admin": is_admin
+            }
+        })
+        
+        # Debug detalhado
+        print("\n=== Debug Auth Response ===")
+        print(f"Tipo: {type(auth_response)}")
+        print(f"Dir: {dir(auth_response)}")
+        print(f"Raw: {auth_response}")
+        
+        if not auth_response:
+            raise Exception("Falha na criação da autenticação")
+        
+        # Tentar diferentes formas de acessar o ID
+        user_id = None
+        if hasattr(auth_response, 'user'):
+            user_id = auth_response.user.id
+        elif hasattr(auth_response, 'id'):
+            user_id = auth_response.id
+        else:
+            # Último recurso: converter para dict
+            auth_dict = auth_response.model_dump() if hasattr(auth_response, 'model_dump') else vars(auth_response)
+            print(f"Auth Dict: {auth_dict}")
+            user_id = auth_dict.get('id') or auth_dict.get('user', {}).get('id')
+        
+        if not user_id:
+            raise Exception("Não foi possível obter o ID do usuário")
+        
+        # 2. Inserir dados na tabela public.users
+        user_data = {
+            "id": user_id,
+            "email": email,
+            "nome": nome,
+            "is_admin": is_admin,
+            "created_at": datetime.utcnow().isoformat(),
+            "updated_at": datetime.utcnow().isoformat(),
+            "is_active": True
+        }
+        
+        response = admin_client.from_('users')\
+            .insert(user_data)\
+            .execute()
+        
+        return response.data[0]
+        
+    except Exception as e:
+        print(f"\n=== Erro Detalhado ===")
+        print(f"Tipo do erro: {type(e)}")
+        print(f"Mensagem: {str(e)}")
+        import traceback
+        print(f"Traceback:\n{traceback.format_exc()}")
+        raise Exception(f"Erro ao criar usuário: {str(e)}")
+
+def delete_user(user_id: str):
+    """Deleta um usuário do sistema"""
+    try:
+        admin_client = SupabaseConnection().get_admin_client()
+        
+        # 1. Deletar da tabela users primeiro
+        response = admin_client.from_('users')\
+            .delete()\
+            .eq('id', user_id)\
+            .execute()
+            
+        # 2. Deletar da autenticação
+        auth_response = admin_client.auth.admin.delete_user(user_id)
+        
+        return True
+        
+    except Exception as e:
+        print(f"\n=== Erro ao deletar usuário ===")
+        print(f"Tipo do erro: {type(e)}")
+        print(f"Mensagem: {str(e)}")
+        import traceback
+        print(f"Traceback:\n{traceback.format_exc()}")
+        raise Exception(f"Erro ao deletar usuário: {str(e)}")
+
+def create_user(email: str, password: str, nome: str):
+    """Cria um novo usuário e seu assistente"""
+    try:
+        # 1. Criar usuário no Supabase
+        user = create_admin_user(
+            email=email,
+            password=password,
+            nome=nome,
+            is_admin=False
+        )
+        
+        # 2. Criar assistente no Pinecone
+        safe_name = "".join(c for c in nome if c.isalnum() or c.isspace()).strip()
+        safe_name = safe_name.lower().replace(" ", "-")
+        assistant_name = f"assistant-{safe_name}-{user['id'][:8]}"
+        
+        config = AssistenteConfig(
+            nome=assistant_name,
+            instrucoes="Você é uma assistente amigável que responde perguntas do usuário. Responda sempre em português do Brasil."
+        )
+        
+        try:
+            criador = CriaAssistente()
+            assistente = criador.criar(config)
+            
+            # 3. Atualizar usuário com referências do assistente
+            admin_client = SupabaseConnection().get_admin_client()
+            response = admin_client.from_('users')\
+                .update({
+                    "assistant_name": assistant_name  # Salvando apenas o nome
+                })\
+                .eq('id', user['id'])\
+                .execute()
+            
+            st.success(f"✅ Usuário {nome} criado com sucesso!")
+            st.success(f"✅ Assistente '{assistant_name}' criado com sucesso!")
+            
+            return response.data[0]
+            
+        except Exception as e:
+            st.error(f"❌ Erro ao criar assistente: {str(e)}")
+            delete_user(user['id'])
+            raise
+            
+    except Exception as e:
+        st.error(f"❌ Erro ao criar usuário: {str(e)}")
+        raise
+
+def main():
+    st.set_page_config(page_title="Cadastro de Usuários", page_icon="👤")
+    
+    st.title("👤 Cadastro de Usuários")
+    st.markdown("### Área Administrativa")
+    
+    # Formulário de cadastro
+    with st.form("admin_cadastro_form"):
+        nome = st.text_input("Nome completo", help="Digite o nome completo do usuário")
+        email = st.text_input("Email", help="Digite o email do usuário")
+        password = st.text_input("Senha", type="password", help="Mínimo 6 caracteres")
+        confirm_password = st.text_input("Confirmar senha", type="password")
+        is_admin = st.checkbox("👑 Usuário Administrador")
+        
+        if st.form_submit_button("Criar Usuário"):
+            try:
+                # Validações
+                if not all([nome, email, password, confirm_password]):
+                    st.error("❌ Todos os campos são obrigatórios!")
+                    st.stop()
+                
+                if password != confirm_password:
+                    st.error("❌ As senhas não coincidem!")
+                    st.stop()
+                
+                if len(password) < 6:
+                    st.error("❌ A senha deve ter no mínimo 6 caracteres!")
+                    st.stop()
+                
+                # Criar usuário
+                user = create_user(
+                    email=email,
+                    password=password,
+                    nome=nome
+                )
+                
+                st.json(user)  # Mostra os dados do usuário criado
+                
+            except Exception as e:
+                st.error(f"❌ Erro ao criar usuário: {str(e)}")
+    
+    # Lista de usuários existentes
+    st.markdown("---")
+    st.subheader("📋 Usuários Cadastrados")
+    
+    try:
+        admin_client = SupabaseConnection().get_admin_client()
+        response = admin_client.from_('users').select('*').execute()
+        
+        if response.data:
+            # Criar DataFrame com os dados
+            df = pd.DataFrame(response.data)
+            
+            # Mostrar tabela
+            st.dataframe(
+                df,
+                column_config={
+                    "nome": "Nome",
+                    "email": "Email",
+                    "is_admin": "Admin",
+                    "is_active": "Ativo",
+                    "created_at": "Criado em"
+                },
+                hide_index=True
+            )
+            
+            # Seleção de usuário para deletar
+            usuarios = [(f"{u['nome']} ({u['email']})", u['id']) for u in response.data]
+            selected_user = st.selectbox(
+                "Selecione um usuário para deletar:",
+                options=usuarios,
+                format_func=lambda x: x[0]
+            )
+            
+            # Botão de deletar com confirmação
+            if st.button("🗑️ Deletar Usuário"):
+                if st.session_state.get('is_admin'):  # Verifica se é admin
+                    user_id = selected_user[1]
+                    
+                    # Confirmação adicional
+                    if st.warning(f"⚠️ Tem certeza que deseja deletar este usuário? Esta ação não pode ser desfeita."):
+                        try:
+                            delete_user(user_id)
+                            st.success("✅ Usuário deletado com sucesso!")
+                            st.rerun()  # Atualiza a página
+                        except Exception as e:
+                            st.error(f"❌ Erro ao deletar usuário: {str(e)}")
+                else:
+                    st.error("❌ Apenas administradores podem deletar usuários!")
+                
+        else:
+            st.info("Nenhum usuário cadastrado.")
+            
+    except Exception as e:
+        st.error(f"❌ Erro ao listar usuários: {str(e)}")
+
+if __name__ == "__main__":
+    main()

oauth/login.py

@@ -0,0 +1,38 @@
+import streamlit as st
+from oauth.user_manager import UserManager
+from sollai.assistentes import Assistente
+
+def main():
+    st.title("🔐 Login")
+    
+    with st.form("login_form"):
+        email = st.text_input("Email")
+        password = st.text_input("Senha", type="password")
+        
+        if st.form_submit_button("Entrar"):
+            try:
+                user_manager = UserManager()
+                user = user_manager.authenticate_user(email, password)
+                
+                if user:
+                    # Guardar dados do usuário
+                    st.session_state['user'] = user
+                    st.session_state['is_authenticated'] = True
+                    
+                    # Carregar assistente usando o nome
+                    assistant_name = user.get('assistant_name')
+                    if assistant_name:
+                        try:
+                            assistente = Assistente(assistant_name)
+                            st.session_state['assistant'] = assistente
+                            st.success("✅ Login realizado com sucesso!")
+                            st.rerun()
+                        except Exception as e:
+                            st.error(f"❌ Erro ao carregar assistente: {str(e)}")
+                    else:
+                        st.error("❌ Você não possui um assistente configurado.")
+                else:
+                    st.error("❌ Email ou senha inválidos!")
+                    
+            except Exception as e:
+                st.error(f"❌ Erro ao fazer login: {str(e)}")

oauth/supabase_conex.py

@@ -0,0 +1,74 @@
+import os
+from dotenv import load_dotenv
+from supabase import create_client, Client
+from typing import Optional
+
+load_dotenv()
+
+class SupabaseConnection:
+    """Gerenciador de conexão com Supabase"""
+    
+    _instance: Optional['SupabaseConnection'] = None
+    
+    def __new__(cls):
+        """Implementa Singleton para evitar múltiplas conexões"""
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+    
+    def __init__(self):
+        """Inicializa a conexão com Supabase"""
+        if not hasattr(self, 'client'):
+            self.supabase_url = os.getenv("SUPABASE_URL")
+            self.supabase_key = os.getenv("SUPABASE_KEY")
+            self.service_role_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+            
+            if not all([self.supabase_url, self.supabase_key, self.service_role_key]):
+                raise ValueError(
+                    "SUPABASE_URL, SUPABASE_KEY e SUPABASE_SERVICE_ROLE_KEY devem estar definidos no arquivo .env"
+                )
+            
+            # Cliente normal para operações regulares
+            self.client = create_client(
+                supabase_url=self.supabase_url,
+                supabase_key=self.supabase_key
+            )
+            
+            # Cliente admin para operações administrativas
+            self.admin_client = create_client(
+                supabase_url=self.supabase_url,
+                supabase_key=self.service_role_key
+            )
+    
+    def get_client(self) -> Client:
+        """Retorna o cliente Supabase regular"""
+        return self.client
+    
+    def get_admin_client(self) -> Client:
+        """Retorna o cliente Supabase com privilégios administrativos"""
+        return self.admin_client
+    
+    def test_connection(self) -> bool:
+        """Testa a conexão com Supabase"""
+        try:
+            # Tenta fazer uma query simples
+            print("🔍 Testando conexão com Supabase...")
+            response = self.client.table('users').select("*").limit(1).execute()
+            print("✅ Conexão Supabase bem sucedida!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Erro na conexão Supabase: {str(e)}")
+            return False
+    
+    def get_table(self, table_name: str):
+        """
+        Retorna uma referência para uma tabela específica
+        
+        Args:
+            table_name: Nome da tabela
+            
+        Returns:
+            PostgrestFilterBuilder: Referência para a tabela
+        """
+        return self.client.table(table_name)

oauth/user_manager.py

@@ -0,0 +1,89 @@
+from datetime import datetime
+from typing import Dict, Optional, List
+from oauth.supabase_conex import SupabaseConnection
+
+class UserManager:
+    """Gerenciador de usuários usando Supabase"""
+    
+    def __init__(self):
+        self.supabase = SupabaseConnection().get_client()
+        self.users_table = 'users'
+    
+    def authenticate_user(self, email: str, password: str) -> Optional[Dict]:
+        """Autentica um usuário"""
+        try:
+            # Autenticar usuário
+            auth_response = self.supabase.auth.sign_in_with_password({
+                "email": email,
+                "password": password
+            })
+            
+            if auth_response:
+                # Usar admin_client para evitar recursão nas políticas
+                admin_client = SupabaseConnection().get_admin_client()
+                
+                # Buscar dados completos do usuário
+                user_response = admin_client.from_('users')\
+                    .select('*')\
+                    .eq('email', email)\
+                    .single()\
+                    .execute()
+                    
+                if user_response.data:
+                    print(f"=== Login realizado com sucesso ===")
+                    print(f"Usuário: {user_response.data['nome']} ({user_response.data['email']})")
+                    
+                    # Verificar se tem assistente
+                    if not user_response.data.get('assistant_name'):
+                        print("✗ Usuário não possui assistente configurado")
+                    
+                    return user_response.data
+                    
+            return None
+            
+        except Exception as e:
+            print(f"Erro na autenticação: {str(e)}")
+            raise
+    
+    def get_user(self, user_id: str) -> Optional[Dict]:
+        """Busca um usuário pelo ID"""
+        try:
+            # Usar admin_client para bypass nas políticas
+            admin_client = SupabaseConnection().get_admin_client()
+            
+            response = admin_client.from_(self.users_table)\
+                .select('*')\
+                .eq('id', user_id)\
+                .execute()
+            
+            return response.data[0] if response.data else None
+            
+        except Exception as e:
+            raise Exception(f"Erro ao buscar usuário: {str(e)}")
+    
+    def get_current_user(self) -> Optional[Dict]:
+        """Retorna o usuário atual"""
+        try:
+            session = self.supabase.auth.get_session()
+            if not session:
+                return None
+            
+            return self.get_user(session.user.id)
+        except Exception as e:
+            print(f"Erro ao buscar usuário atual: {str(e)}")
+            return None
+    
+    def is_admin(self, user_id: str) -> bool:
+        """Verifica se um usuário é admin"""
+        try:
+            user = self.get_user(user_id)
+            return user.get('is_admin', False) if user else False
+        except Exception as e:
+            print(f"Erro ao verificar admin: {str(e)}")
+            return False
+
+# Exemplo de uso
+if __name__ == "__main__":
+    user_manager = UserManager()
+    
+    

sollai/__init__.py

@@ -0,0 +1 @@
+# Este arquivo pode ficar vazio 

sollai/assistentes.py

@@ -0,0 +1,161 @@
+import os
+from dotenv import load_dotenv
+from pinecone import Pinecone
+from pinecone_plugins.assistant.models.chat import Message
+from rich.console import Console
+from rich.panel import Panel
+from dataclasses import dataclass
+from typing import List, Optional, Dict, Generator
+from pathlib import Path
+from datetime import datetime
+
+
+load_dotenv()
+
+@dataclass
+class AssistenteConfig:
+    """Configuração do assistente"""
+    nome: str
+    instrucoes: str
+
+class CriaAssistente:
+    """Classe responsável por criar e configurar assistentes"""
+    
+    def __init__(self):
+        self.pc = Pinecone(api_key=os.getenv('PINECONE_API_KEY'))
+        self.console = Console()
+    
+    def criar(self, config: AssistenteConfig) -> Dict:
+        """Cria um novo assistente com as configurações especificadas"""
+        try:
+            assistant = self.pc.assistant.create_assistant(
+                assistant_name=config.nome,
+                instructions=config.instrucoes,
+                timeout=30
+            )
+            
+            self.console.print(
+                f"[green]✓ Assistente '{config.nome}' criado com sucesso![/green]"
+            )
+            return assistant
+            
+        except Exception as e:
+            self.console.print(f"[red]✗ Erro ao criar assistente: {str(e)}[/red]")
+            raise
+
+class Assistente:
+    """Classe para interagir com assistentes existentes"""
+    
+    def __init__(self, assistant_name: str):
+        self.pc = Pinecone(api_key=os.getenv('PINECONE_API_KEY'))
+        self.console = Console()
+        self.nome = assistant_name
+        self.assistente = self.pc.assistant.Assistant(assistant_name=assistant_name)
+    
+    def get_context(self, query: str) -> List[Dict]:
+        """Busca snippets relevantes para uma query"""
+        try:
+            response = self.assistente.context(query=query)
+            if response is None:
+                return []
+            
+            # Verificar se response é um dicionário
+            if isinstance(response, dict):
+                return response.get("snippets", [])
+            # Se for uma lista, retornar diretamente
+            elif isinstance(response, list):
+                return response
+            return []
+        
+        except Exception as e:
+            self.console.print(f"[red]✗ Erro ao buscar contexto: {str(e)}[/red]")
+            return []
+
+    def fazer_pergunta(self, pergunta: str) -> Dict:
+        """Faz uma pergunta ao assistente com contexto"""
+        try:
+            # Primeiro buscar contexto relevante
+            snippets = self.get_context(pergunta)
+            
+            # Fazer a pergunta
+            msg = Message(content=pergunta)
+            response = self.assistente.chat(messages=[msg])
+            
+            # Extrair conteúdo e citações
+            content = response["message"]["content"]
+            citations = response.get("citations", [])
+            
+            return {
+                "content": content,
+                "citations": citations,
+                "snippets": snippets  # Incluir snippets na resposta
+            }
+            
+        except Exception as e:
+            self.console.print(f"[red]✗ Erro ao fazer pergunta: {str(e)}[/red]")
+            raise
+    
+    def _process_stream(self, chunks: Generator) -> Dict:
+        """Processa o stream de resposta"""
+        content = ""
+        citations = []
+        
+        for chunk in chunks:
+            if not chunk:
+                continue
+                
+            # Processar diferentes tipos de chunks
+            if isinstance(chunk, dict):
+                chunk_type = chunk.get("type")
+                
+                if chunk_type == "message_start":
+                    continue
+                elif chunk_type == "content_chunk":
+                    if "delta" in chunk and "content" in chunk["delta"]:
+                        content += chunk["delta"]["content"]
+                elif chunk_type == "citation":
+                    citations.append(chunk.get("citation", {}))
+                elif chunk_type == "message_end":
+                    if chunk.get("finish_reason") == "stop":
+                        break
+            else:
+                content += str(chunk)
+        
+        return {
+            "content": content,
+            "citations": citations
+        }
+    
+    def upload_file(self, file_path: str, timeout: Optional[int] = None) -> Dict:
+        """Faz upload de um arquivo para o assistente"""
+        try:
+            # Adicionar metadados com nome original do arquivo
+            original_name = Path(file_path).name
+            metadata = {
+                "original_name": original_name,
+                "uploaded_on": datetime.now().isoformat()
+            }
+            
+            response = self.assistente.upload_file(
+                file_path=file_path,
+                timeout=timeout,
+                metadata=metadata
+            )
+            return response
+        except Exception as e:
+            self.console.print(f"[red]✗ Erro ao fazer upload: {str(e)}[/red]")
+            raise
+
+    def get_files(self) -> List[Dict]:
+        """Retorna a lista de arquivos carregados no assistente"""
+        try:
+            response = self.assistente.list_files()
+            if isinstance(response, list):
+                return response
+            elif isinstance(response, dict):
+                return response.get("files", [])
+            return []
+        except Exception as e:
+            self.console.print(f"[red]✗ Erro ao listar arquivos: {str(e)}[/red]")
+            return []
+

sollai/chat.py

@@ -0,0 +1,267 @@
+import streamlit as st
+import os
+from pathlib import Path
+from typing import List, Dict
+import tempfile
+from pinecone import Pinecone
+from datetime import datetime
+
+def save_uploaded_file(file) -> str:
+    """Salva um arquivo temporariamente e retorna o caminho"""
+    with tempfile.NamedTemporaryFile(delete=False, suffix=Path(file.name).suffix) as tmp:
+        tmp.write(file.getvalue())
+        return tmp.name
+
+def format_citation(citation: dict, index: int) -> str:
+    """Formata uma citação com estilo de referência acadêmica"""
+    try:
+        references = citation.get("references", [])
+        position = citation.get("position", 0)
+        citation_text = []
+        
+        for ref in references:
+            if not ref:
+                continue
+                
+            file_data = ref.get("file", {}) or {}
+            metadata = file_data.get("metadata", {}) or {}
+            
+            # Usar nome original do arquivo se disponível
+            file_name = (metadata.get("original_name") 
+                        or file_data.get("name", "Documento"))
+            pages = ref.get("pages", [])
+            
+            # Criar link de referência
+            citation_text.append(f"[{index}] {file_name}")
+            if pages:
+                citation_text.append(f"Page{'s' if len(pages) > 1 else ''} {', '.join(map(str, pages))}")
+        
+        return " | ".join(citation_text)
+    except Exception as e:
+        st.error(f"Erro ao formatar citação: {str(e)}")
+        return f"[{index}] Referência"
+
+def show_references(citations: List[dict]):
+    """Mostra a seção de referências no estilo acadêmico com trechos relevantes"""
+    if not citations:
+        return
+    
+    st.markdown("---")
+    st.markdown("### References:")
+    
+    for i, citation in enumerate(citations, 1):
+        try:
+            references = citation.get("references", [])
+            position = citation.get("position", 0)
+            
+            for ref in references:
+                if not ref:
+                    continue
+                    
+                file_data = ref.get("file", {}) or {}
+                metadata = file_data.get("metadata", {}) or {}
+                
+                # Usar nome original do arquivo
+                file_name = (metadata.get("original_name") 
+                            or file_data.get("name", "Documento"))
+                pages = ref.get("pages", [])
+                
+                with st.container():
+                    # Cabeçalho da referência
+                    col1, col2 = st.columns([1, 4])
+                    with col1:
+                        st.markdown(f"**[{i}]**")
+                    with col2:
+                        st.markdown(f"**{file_name}**")
+                        if pages:
+                            st.caption(f"Page {', '.join(map(str, pages))}")
+                    
+                    # Trecho relevante
+                    if position is not None and citation.get("text"):
+                        with st.expander("Ver trecho citado"):
+                            st.caption("Trecho relevante:")
+                            st.markdown("> " + citation["text"].strip())
+                    
+                    st.divider()
+        except Exception as e:
+            st.error(f"Erro ao mostrar referência {i}: {str(e)}")
+
+def format_snippet(snippet: dict) -> str:
+    """Formata um snippet de contexto"""
+    try:
+        content = snippet.get("content", "").strip()
+        score = snippet.get("score", 0)
+        reference = snippet.get("reference", {}) or {}
+        file_data = reference.get("file", {}) or {}
+        metadata = file_data.get("metadata", {}) or {}
+        
+        # Pegar nome original do arquivo se disponível
+        file_name = (metadata.get("original_name") 
+                    or file_data.get("name", "Documento"))
+        
+        # Pegar páginas
+        pages = reference.get("pages", [])
+        page_info = f"Page {', '.join(map(str, pages))}" if pages else ""
+        
+        # Formatar texto
+        return f"""
+        📄 **Fonte:** {file_name} {page_info}
+        📊 **Relevância:** {score:.2%}
+        
+        > {content}
+        """
+    except Exception as e:
+        return f"❌ Erro ao formatar snippet: {str(e)}"
+
+def show_context(snippets: List[dict]):
+    """Mostra snippets de contexto relevantes"""
+    if not snippets:
+        return
+        
+    with st.expander("🔍 **Contexto Relevante**"):
+        try:
+            st.info("ℹ️ Trechos relevantes encontrados nos documentos:")
+            
+            for snippet in snippets:
+                if snippet:  # Verificar se o snippet é válido
+                    st.markdown(format_snippet(snippet))
+                    st.divider()
+        except Exception as e:
+            st.error(f"❌ Erro ao mostrar contexto: {str(e)}")
+
+def main():
+    st.title("💬 Chat")
+    
+    if 'assistant' not in st.session_state:
+        st.error("❌ Nenhum assistente configurado!")
+        return
+    
+    # Área de documentos
+    with st.sidebar:
+        st.subheader("📁 Documentos")
+        
+        # Mostrar contagem de documentos
+        try:
+            files = st.session_state['assistant'].get_files()
+            total_files = len(files)
+            
+            # Mostrar status dos documentos
+            if total_files > 0:
+                st.info(f"📊 {total_files} documento{'s' if total_files > 1 else ''} carregado{'s' if total_files > 1 else ''}")
+                
+                # Mostrar detalhes em um expander
+                with st.expander("Ver detalhes dos documentos"):
+                    for file in files:
+                        with st.container():
+                            st.text(f"📄 {file['name'] if 'name' in file else 'Documento'}")
+                            if 'size' in file:
+                                st.caption(f"📦 {file['size']/1024:.1f} KB")
+                            if 'created_on' in file:
+                                st.caption(f"📅 {file['created_on']}")
+                            st.divider()
+            else:
+                st.warning("⚠️ Nenhum documento carregado")
+            
+        except Exception as e:
+            st.error(f"❌ Erro ao carregar documentos: {str(e)}")
+            st.warning("⚠️ Nenhum documento carregado")
+        
+        st.info("ℹ️ Carregue documentos para permitir que o assistente os utilize nas respostas.")
+        
+        # Upload de arquivos
+        uploaded_files = st.file_uploader(
+            "Carregar documentos",
+            accept_multiple_files=True,
+            type=['pdf', 'txt', 'doc', 'docx']
+        )
+        
+        if uploaded_files:
+            if st.button("📤 Enviar Documentos"):
+                with st.spinner("Carregando documentos..."):
+                    try:
+                        for uploaded_file in uploaded_files:
+                            with st.status(f"Processando {uploaded_file.name}..."):
+                                temp_path = save_uploaded_file(uploaded_file)
+                                try:
+                                    response = st.session_state['assistant'].upload_file(temp_path)
+                                    st.success("✅ Arquivo processado!")
+                                finally:
+                                    try:
+                                        os.unlink(temp_path)
+                                    except:
+                                        pass
+                                        
+                        st.success("✅ Todos os documentos foram carregados!")
+                        st.rerun()
+                        
+                    except Exception as e:
+                        st.error(f"❌ Erro: {str(e)}")
+
+    # Interface do chat
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    # Mostrar mensagens anteriores
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+            
+            # Mostrar citações se existirem
+            if message.get("citations"):
+                with st.expander("📚 **Fontes Consultadas**"):
+                    st.info("ℹ️ O assistente baseou sua resposta nos seguintes documentos:")
+                    for i, citation in enumerate(message["citations"], 1):
+                        st.markdown(format_citation(citation, i))
+
+    # Input do usuário
+    if prompt := st.chat_input("Digite sua mensagem..."):
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.markdown(prompt)
+            
+        with st.chat_message("assistant"):
+            try:
+                response = st.session_state['assistant'].fazer_pergunta(prompt)
+                
+                # Mostrar contexto relevante primeiro
+                if response.get("snippets"):
+                    show_context(response["snippets"])
+                
+                # Mostrar resposta com citações inline
+                content = response["content"]
+                citations = response.get("citations", [])
+                
+                # Processar citações e extrair trechos
+                processed_citations = []
+                for citation in citations:
+                    # Extrair o trecho do texto original
+                    position = citation.get("position", 0)
+                    text_before = content[max(0, position-100):position]
+                    text_after = content[position:position+100]
+                    citation["text"] = f"...{text_before}**{text_after}**..."
+                    processed_citations.append(citation)
+                
+                # Adicionar números de referência ao conteúdo
+                for i, citation in enumerate(processed_citations, 1):
+                    position = citation.get("position", 0)
+                    content = content[:position] + f" [{i}]" + content[position:]
+                
+                # Mostrar conteúdo
+                st.markdown(content)
+                
+                # Mostrar seção de referências
+                if processed_citations:
+                    show_references(processed_citations)
+                
+                # Salvar mensagem
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": content,
+                    "citations": processed_citations
+                })
+                
+            except Exception as e:
+                st.error(f"❌ Erro: {str(e)}")
+
+if __name__ == "__main__":
+    main()