Adding new features: feedback and login/create acount

config/edgedb/dbschema/initial.esdl

@@ -34,16 +34,21 @@ module default {
           url -> str;
     }
 
+    type User {
+        username -> str {
+            constraint exclusive;
+        };
+        password -> str;
+    }
+
     type Chat {
         required property created_at -> datetime {
             default := datetime_current();
         };
 
-        required property user -> str;
-
-        # Relacionamento com as mensagens
-        multi link messages -> Message {
+        required link user -> User {
             constraint exclusive;
+            on target delete delete source;
         };
     }
 
@@ -52,9 +57,12 @@ module default {
             default := datetime_current();
         };
         required property content -> str;
+        required property role -> str;
 
         # Relacionamento com o chat
-        required link chat -> Chat;
+        required link chat -> Chat {
+            on target delete delete source;
+        };
 
         # Relacionamento com o feedback
         optional link feedback -> Feedback;
@@ -71,6 +79,8 @@ module default {
         };
 
         # Relacionamento com a mensagem
-        required link message -> Message;
+        required link message -> Message {
+            on target delete delete source;
+        };
     }
-}
+}

config/edgedb/dbschema/migrations/00004-m14umub.edgeql

@@ -0,0 +1,16 @@
+CREATE MIGRATION m14umubvchh6dqfs7hxsh6sbq6frts3srp4hem3ste7x55725xfzca
+    ONTO m1i7x3r7aiqye7qwxi5glhcjdwaameqzw5myzghwlvyw6l4tlgiwqq
+{
+  ALTER TYPE default::Chat {
+      DROP PROPERTY user;
+  };
+  CREATE TYPE default::User {
+      CREATE PROPERTY password: std::str;
+      CREATE PROPERTY username: std::str;
+  };
+  ALTER TYPE default::Chat {
+      CREATE REQUIRED LINK user: default::User {
+          SET REQUIRED USING (<default::User>{});
+      };
+  };
+};

config/edgedb/dbschema/migrations/00005-m13l5i4.edgeql

@@ -0,0 +1,19 @@
+CREATE MIGRATION m13l5i44vh6iltkc5kry2aywhsu6hsutbmuhrlkjic4bxdde25dyfq
+    ONTO m14umubvchh6dqfs7hxsh6sbq6frts3srp4hem3ste7x55725xfzca
+{
+  ALTER TYPE default::Chat {
+      ALTER LINK user {
+          CREATE CONSTRAINT std::exclusive;
+      };
+  };
+  ALTER TYPE default::Message {
+      CREATE REQUIRED PROPERTY role: std::str {
+          SET REQUIRED USING (<std::str>{});
+      };
+  };
+  ALTER TYPE default::User {
+      ALTER PROPERTY username {
+          CREATE CONSTRAINT std::exclusive;
+      };
+  };
+};

config/edgedb/dbschema/migrations/00006-m14njc2.edgeql

@@ -0,0 +1,20 @@
+CREATE MIGRATION m14njc2voirnwk4thadcprrevsmlp2wljtwwcnirsya5bblwtljgla
+    ONTO m13l5i44vh6iltkc5kry2aywhsu6hsutbmuhrlkjic4bxdde25dyfq
+{
+  ALTER TYPE default::Chat {
+      DROP LINK messages;
+      ALTER LINK user {
+          ON TARGET DELETE DELETE SOURCE;
+      };
+  };
+  ALTER TYPE default::Feedback {
+      ALTER LINK message {
+          ON TARGET DELETE DELETE SOURCE;
+      };
+  };
+  ALTER TYPE default::Message {
+      ALTER LINK chat {
+          ON TARGET DELETE DELETE SOURCE;
+      };
+  };
+};

interface/app.py

@@ -7,23 +7,42 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 # Importando módulos necessários
 from interface.chatbot import Chatbot
+from interface.login import Login
 
 
 def main():
     app = Chatbot()
-    
-    with st.sidebar:
-        app.create_sidebar()
+    login = Login()
 
-    app.mount_chatbot()
+    if not st.session_state.user_authorized:
+        login.mount_login_page()
 
-    if app.response:
-        app.add_to_history(app.response, role="user")
-        st.chat_message("user").write(app.response)
+    else:
+        with st.sidebar:
+            app.create_sidebar()
 
-        app.generate_answer(app.response)
+        user_query = app.mount_chatbot() # Recebe o input de texto feito pelo usuário
+        app.display_chat()
 
-        app.response = ""  # Zerando a variável após uso
+        if st.session_state.is_feedback_active:
+            app.display_feedback()
+
+        if app.user_button_input:
+            st.chat_message("user").write(app.user_button_input)
+
+            app.generate_answer(app.user_button_input)
+
+            app.user_button_input = ""    # Zerando a variável após uso
+            st.session_state.is_feedback_active = True # Ativando o feedback
+            app.display_feedback()
+
+        if user_query:
+            # Escreve e armazena a mensagem do usuário
+            st.chat_message("user").write(user_query)
+
+            app.generate_answer(user_query) # Gera, envia e armazena a resposta do assistente
+            st.session_state.is_feedback_active = True   # Ativando o feedback
+            app.display_feedback()
 
 
 if __name__ == "__main__":

interface/chatbot.py

@@ -5,31 +5,15 @@ import edgedb
 from openai import OpenAI
 from qdrant_client import QdrantClient
 import streamlit as st
-import argparse
-
-from utils.util import clear_enviromnent_variables
 
 # Add the parent directory to the Python path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 from pipelines.message import send_message # noqa
 
-st.set_page_config(page_title="Carlos AI Agent")
-
-# Parser for command-line options
-parser = argparse.ArgumentParser(description="Argumento para setar qual variável de ambiente usar")
-parser.add_argument('--type_env', type=str, default="prod", help="Set 'dev' for use .env.development and 'prod' for .env")
-
-# Parsing arguments
-args = parser.parse_args()
+# st.set_page_config(page_title="Carlos AI Agent")
 
-# Accessing the correct argument
-type_env = args.type_env
-
-if type_env == "prod":
-    load_dotenv(dotenv_path=".env", override=True)
-else:
-    load_dotenv(dotenv_path=".env.development", override=True)
+load_dotenv()
 
 @st.cache_resource
 def connect_to_services():
@@ -37,78 +21,110 @@ def connect_to_services():
         api_key=os.environ.get("OPENAI_API_KEY")
     )
 
-    edgedb_client = None
-    qdrant_client = None
-    if type_env == "prod":
-            edgedb_client = edgedb.create_client()
-            qdrant_client = QdrantClient(
-                url=os.environ.get("QDRANT_URL"),
-                api_key=os.environ.get("QDRANT_KEY")
-            )
-    else:
-            edgedb_client = edgedb.create_client(
-                host=os.environ.get("EDGEDB_HOST"),
-                user=os.environ.get("EDGEDB_USER"),
-                password=os.environ.get("EDGEDB_PASSWORD"),
-                port=os.environ.get("EDGEDB_PORT"),
-                tls_security="insecure"
-            )
-            qdrant_client = QdrantClient(
-                 host=os.environ.get("QDRANT_HOST"),
-                port=os.environ.get("QDRANT_PORT")
-            )
+    qdrant_client = QdrantClient(
+        url=os.environ.get("QDRANT_URL"),
+        api_key=os.environ.get("QDRANT_KEY")
+    )
+
+    edgedb_client = edgedb.create_client()
 
     return oa_client, qdrant_client, edgedb_client
 
-class Chatbot():
+
+class Chatbot:
     def __init__(self):
-        # Configuração inicial do histórico de chat
-        if "chat_history" not in st.session_state:
-            st.session_state.chat_history = [{
-                "role": "assistant",
-                "content": "Como eu posso ajudar?"
-            }]
-        
         # Conteúdo dos botões do sidebar
         if "topics" not in st.session_state:
-            st.session_state["topics"] = [
-                "Niveis da conta govbr.",
+            st.session_state.topics = [
+                "Níveis da conta govbr.",
                 "Dúvidas no reconhecimento facial.",
                 "Como recuperar minha conta gov.br",
-                "Dúvidas para aumentar o nível com a cin."
+                "Dúvidas para aumentar o nível com a CIN."
             ]
+
+        if "services" not in st.session_state:
+            oa_client, qdrant_client, edgedb_client =  connect_to_services()
+            st.session_state.services = {
+                "oa_client": oa_client, 
+                "qdrant_client": qdrant_client, 
+                "edgedb_client": edgedb_client
+            }
+        
+        if "chat" not in st.session_state and st.session_state.get('username'):
+            chat = st.session_state.services["edgedb_client"].query('''
+                Select Chat {
+                    id
+                } filter .user.username = <str>$username
+            ''', username=st.session_state.username)
+
+            if not chat:
+                chat = self._create_default_chat()
+            else:
+                chat = chat[0]
+                self.update_messages(chat)
+            
+            st.session_state.chat = chat
+
         
-        # Pergunta do usuário no chatbot
-        self.response = ""
 
-        self.oa_client, self.qdrant_client, self.edgedb_client =  connect_to_services()
+        if "is_feedback_active" not in st.session_state:
+            st.session_state.is_feedback_active = False
 
+        
+        self.user_button_input = ""     # Pergunta do usuário no chat
+        # self.is_feedback_active = False # Flag para ativar o feedback do o
     
+    def _create_default_chat(self):
+        chat = st.session_state.services["edgedb_client"].query('''
+                    INSERT Chat {
+                        user := (SELECT User FILTER .username = <str>$username)
+                    }
+                ''', username=st.session_state.username)
+        message = st.session_state.services["edgedb_client"].query('''
+            SELECT (
+                INSERT Message {
+                    content := "Como eu posso ajudar?",
+                    role := "assistant",
+                    chat := (SELECT Chat FILTER .id = <uuid>$chat_id)
+                }
+            ) {
+                content,
+                role                                             
+            }
+        ''', chat_id=chat[0].id)
+        st.session_state.chat_history = message
+        return chat[0]
+
+    def _save_msg_to_db(self, msg, role):
+        st.session_state.services["edgedb_client"].query('''
+            INSERT Message {
+                content := <str>$content,
+                chat := (SELECT Chat FILTER .id = <uuid>$chat_id),
+                role := <str>$role
+            }
+        ''', content=msg, chat_id=st.session_state.chat.id, role=role)
+    
+
     def mount_chatbot(self):
         # Exibição do título e subtítulo
         st.title("Bem-vindo à ajuda do gov.br")
         st.caption("💬 Qual a sua dificuldade hoje? Estou aqui para ajudar!")
 
-        self.display_chat(st.session_state.chat_history, jump_last_message=False)
-
         # Exibição do espaço para mandar mensagem
         if user_query := st.chat_input(placeholder="Digite sua mensagem"):
-            self.add_to_history(user_query, role="user")
-            st.chat_message("user").write(user_query)
-
-            # Simulação de resposta do assistente
-            self.generate_answer(user_query)
+            st.session_state.is_feedback_active = False # Desativando o feedback
+            return user_query
     
-            
+
     def create_sidebar(self):
         st.image('https://www.gov.br/++theme++padrao_govbr/img/govbr-logo-large.png', width=200)
         st.header("Tópicos frequentes")
         
         for topic in st.session_state.topics:
             if st.button(topic, key=topic):
-                self.response = topic
+                self.user_button_input = topic
+                st.session_state.is_feedback_active = False # Desativando o feedback
 
-        
         # Espaços em branco para organização
         for _ in range(5):
             st.write("")
@@ -117,19 +133,22 @@ class Chatbot():
         col1, col2, col3 = st.columns([1, 2, 1])
         with col2:
             if st.button("LIMPAR HISTÓRICO"):
-                st.session_state.chat_history = [{
-                    "role": "assistant",
-                    "content": "Como eu posso ajudar?",
-                }]
+                st.session_state.services["edgedb_client"].query('''
+                    DELETE Chat
+                    FILTER .id = <uuid>$chat_id;
+                ''', chat_id=st.session_state.chat.id)
+                st.session_state.chat = self._create_default_chat()
+                st.session_state.is_feedback_active = False # Desativando o feedback
+    
 
     def send_message_for_ai(self, prompt):
         with st.spinner("Obtendo conteúdo da página..."):
-            embedding = self.oa_client.embeddings.create(
+            embedding = st.session_state.services["oa_client"].embeddings.create(
                 input=[prompt],
                 model=os.environ.get("OPENAI_MODEL_EMBEDDING")
             ).data[0].embedding
         
-            child_texts = self.qdrant_client.search(
+            child_texts = st.session_state.services["qdrant_client"].search(
                 collection_name=os.environ.get("COLLECTION_NAME"), 
                 query_vector=embedding,
                 limit=3
@@ -138,7 +157,7 @@ class Chatbot():
             contexts = []
         
             for child_text in child_texts:
-                parent_text = self.edgedb_client.query('''
+                parent_text = st.session_state.services["edgedb_client"].query('''
                     SELECT Pattern {
                         content,
                         url,
@@ -152,37 +171,79 @@ class Chatbot():
                     "parent_id": parent_text.parent_id
                 }
                 contexts.append(context)
-        
             
+            formatted_messages = [{"content": msg.content, "role": msg.role} for msg in st.session_state.chat_history]
+
+            self._save_msg_to_db(prompt, "user")
+         
             stream_response = send_message(
-                self.oa_client,
+                st.session_state.services["oa_client"],
                 contexts,
                 prompt,
-                []
+                formatted_messages
             )
 
             return stream_response
-        
+
+
     def generate_answer(self, prompt):
-        
         with st.chat_message("assistant"):
             stream_response = self.send_message_for_ai(prompt)
             response = st.write_stream(stream_response)
-            
-        self.add_to_history(response, role="assistant")
-
-    def display_chat(self, messages_list, jump_last_message: bool = True):
-        if jump_last_message:
-            messages = messages_list[:-1] # Desconsidera o último item da lista
-        else:
-            messages = messages_list  # Mostra todos os itens da lista original
-
-        for message in messages:
-            st.chat_message(message["role"]).write(message["content"])
-
-    def add_to_history(self, message, role="user"):
-        st.session_state.chat_history.append({
-            "role": role,
-            "content": message
-            })
+        self._save_msg_to_db(response, "assistant")
+        self.update_messages(st.session_state.chat)
+    
 
+    def display_chat(self):
+        for message in st.session_state.chat_history:
+            st.chat_message(message.role).write(message.content)
+    
+    def update_messages(self, chat):
+        messages = st.session_state.services["edgedb_client"].query('''
+            SELECT Message {
+                id,
+                content,
+                role
+            } 
+            FILTER .chat.id = <uuid>$chat_id
+            ORDER BY .created_at ASC;
+        ''', chat_id=chat.id)
+        st.session_state.chat_history = messages
+
+    def display_feedback(self):
+        user_input = st.session_state.chat_history[-2].content
+        bot_output = st.session_state.chat_history[-1].content
+
+        with st.expander("Avaliação do atendimento"):
+            st.write(f'O que achou da resposta para a pergunta "{user_input}"?')
+            
+            rate = st.feedback("stars")
+            # rate = st.feedback("faces")
+
+            text_feedback = st.text_input("Comentários extras:")
+
+            # Botão para confirmar a avaliação
+            if rate is not None:
+                if st.button("Enviar Avaliação"):
+                    try:
+                        feedback_rate = rate + 1
+                        st.session_state.services["edgedb_client"].query('''
+                            INSERT Feedback {
+                                rating := <int16>$rating,
+                                content := <str>$content,
+                                message := (SELECT Message FILTER .id = <uuid>$message_id)
+                            }
+                        ''',
+                        message_id=st.session_state.chat_history[-1].id,
+                        rating=feedback_rate,
+                        content=text_feedback,
+                        )
+                        st.session_state.chat_history
+                        st.success(f"Avaliação enviada!")
+                    except Exception as e:
+                        print(e)
+                        st.error("Erro ao enviar avaliação!")
+
+                    st.session_state.is_feedback_active = False # Desativando o feedback
+
+                    # TODO Colocar nessa parte a estrutura para adicionar o feedback_data ao banco de dados

interface/login.py

@@ -0,0 +1,110 @@
+import streamlit as st
+import json
+import sys
+import os
+import bcrypt
+
+from interface.chatbot import connect_to_services
+
+# Add the parent directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+class Login:
+    def __init__(self):
+        if "username" not in st.session_state:
+            st.session_state.username = ""
+        
+        if "user_authorized" not in st.session_state:
+            st.session_state.user_authorized = False
+        
+        if "services" not in st.session_state:
+            oa_client, qdrant_client, edgedb_client =  connect_to_services()
+            st.session_state.services = {
+                "oa_client": oa_client, 
+                "qdrant_client": qdrant_client, 
+                "edgedb_client": edgedb_client
+            }
+
+
+        self.username = ""
+        self.password = ""
+    
+    
+    def mount_login_page(self):
+        # Exibição do título e subtítulo
+        st.title("Bem-vindo à ajuda do gov.br")
+        with st.form("login_form"):
+            st.title("Login")
+
+            username = st.text_input('E-mail:')
+            password = st.text_input('Senha:', type='password')
+            submitted = st.form_submit_button("Entrar")
+            st.text("Não possui uma conta?")
+            create_account = st.form_submit_button("Criar uma conta")
+
+            if create_account:
+                if not username:
+                    st.warning("Digite um email para cadastrar a conta.")
+                
+                if not password:
+                    st.warning("Digite uma senha para cadastrar a conta.")
+                
+                if username and password:
+                    if "@" not in username:
+                        st.warning("Digite um email válido para cadastrar a conta.")
+                    
+                    else:
+                        user = self.validate_credentials(username, password, return_just_user=True)
+                        if user:
+                            st.warning("Já existe uma conta usando este email")
+                        else:
+                            # Gerando senha encriptada
+                            hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+                            hashed_password_str = hashed_password.decode('utf-8')
+
+                            st.session_state.services["edgedb_client"].query('''
+                                INSERT User {
+                                    username := <str>$username,
+                                    password := <str>$password
+                                }
+                            ''',
+                                username=username, \
+                                password=hashed_password_str, \
+                            )
+
+                            st.success("Conta cadastrada com sucesso.")       
+
+            if submitted:
+                if username and password:
+                    checked = self.validate_credentials(username, password)
+                    if checked:
+                        st.success("Usuário logado!")
+                        st.session_state.user_authorized = True
+                        st.session_state.username = username
+                        st.rerun()
+
+                    else:
+                        st.error("Nome de usuário ou senha inválidos.")
+
+                else:
+                    st.warning("Digite o nome do usuário e a senha.")
+    
+
+    def validate_credentials(self, username, password, return_just_user=False):
+        user = st.session_state.services["edgedb_client"].query('''
+            SELECT User {
+                username,
+                password
+            } FILTER .username = <str>$username
+        ''', username=username)
+
+        if return_just_user:
+            if not user:
+                return False
+            
+            return True
+
+        if not user or not bcrypt.checkpw(password.encode('utf-8'), user[0].password.encode('utf-8')):
+            return False
+        
+        return True

requirements.txt

@@ -3,6 +3,7 @@ annotated-types==0.7.0
 anyio==4.5.0
 async-timeout==4.0.3
 attrs==24.2.0
+bcrypt==4.2.0
 blinker==1.8.2
 cachetools==5.5.0
 certifi==2024.8.30