Merge menu into main

Author: gcapuzzi

agents.py

@@ -0,0 +1,28 @@
+import os
+from utils import load_yaml_file
+from dotenv import load_dotenv, find_dotenv
+from mistralai import Mistral
+
+config_data = load_yaml_file("config.yaml")
+load_dotenv(find_dotenv())
+
+# Get API key
+mistral_api_key = os.getenv("MISTRALAI_API_KEY")
+client = Mistral(mistral_api_key)
+
+def get_websearch_agent():
+    """
+    Create and return a web search agent using Mistral API.
+    """
+    websearch_agent = client.beta.agents.create(
+        model=config_data["model_name"],
+        description="Agent able to search information over the web",
+        name="Websearch Agent",
+        instructions="You have the ability to perform web searches with `web_search` to find up-to-date information. **Always provide the source URLs when you use web search to answer a question.**",
+        tools=[{"type": "web_search"}],
+        completion_args={
+            "temperature": 0.3,
+            "top_p": 0.95,
+        }
+    )
+    return websearch_agent

app.py

@@ -1,40 +1,39 @@
 import streamlit as st
-from menu import menu
+from menu import menu, unauthenticated_menu
 from database import create_connection, create_table, get_user, insert_user
 from homepage import gethomepage
 
 # Get markdown homepage
 st.markdown(body=gethomepage(), unsafe_allow_html=True)
 
-# Check if user is authenticated
-if not st.user.is_logged_in:
-    if st.button("Log in or Sign up"):
-        st.login("auth0")
-    st.stop()
-
-# Initialize session state
+# Initialize session state for user_type and username
 if "user_type" not in st.session_state:
     st.session_state.user_type = None
 if "username" not in st.session_state:
     st.session_state.username = None
 
-# Only access user info if available
-if hasattr(st.user, "email"):
+# Check if user is authenticated
+if st.user.is_logged_in:
     conn = create_connection()
     if conn is not None:
         create_table(conn)
-
-        # Check if user exists
         user_data = get_user(conn, st.user.email)
         if user_data is not None:
             st.session_state['user_type'] = user_data[3]
             st.session_state['username'] = user_data[1]
         else:
-            user_type = 'guest'
+            user_type = 'user'
             username = st.user.email
             st.session_state['user_type'] = user_type
             st.session_state['username'] = username
             insert_user(conn, username, st.user.email, user_type)
-
-# Show menu
-menu()
+    
+    # Show authenticated menu
+    menu()
+    
+else:
+    st.session_state['user_type'] = 'guest'
+    st.session_state['username'] = 'guest'
+    
+    # Show menu for unauthenticated users, which will now have a link to the chatbot
+    unauthenticated_menu()

chat_history.py

@@ -1,37 +1,93 @@
 import sqlite3
+import streamlit as st
+from utils import load_yaml_file
 
-DB_FILE = "users.db"
+# Read config data
+config_data = load_yaml_file("config.yaml")
+
+DB_FILE = config_data["dbpath"]
 
 # create a SQLite database to store chat history
 # and user information
 def init_db():
     with sqlite3.connect(DB_FILE) as conn:
         conn.execute('''
-            CREATE TABLE IF NOT EXISTS messages (
+CREATE TABLE IF NOT EXISTS messages (
                 id INTEGER PRIMARY KEY AUTOINCREMENT,
                 username TEXT NOT NULL,
                 role TEXT NOT NULL,
                 content TEXT NOT NULL,
-                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+                feedback INTEGER DEFAULT NULL,
+                session_id TEXT DEFAULT NULL,
+                ip_address TEXT DEFAULT NULL
+            )
+        ''')
+        
+        cursor = conn.execute("PRAGMA table_info(messages)")
+        existing_columns = [col[1] for col in cursor.fetchall()]
+
+        if "feedback" not in existing_columns:
+            conn.execute('ALTER TABLE messages ADD COLUMN feedback INTEGER DEFAULT NULL')
+
+        if "session_id" not in existing_columns:
+            conn.execute('ALTER TABLE messages ADD COLUMN session_id TEXT DEFAULT NULL')
+
+        if "ip_address" not in existing_columns:
+            conn.execute('ALTER TABLE messages ADD COLUMN ip_address TEXT DEFAULT NULL')    
+        
+        conn.execute('''
+            CREATE TABLE IF NOT EXISTS analytics (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                title TEXT NOT NULL,
+                sql_query TEXT NULL,
+                options TEXT NULL,
+                notes TEXT NULL
             )
         ''')
+
         conn.commit()
 
 # create a table to store user information
-def save_message(username, role, content):
+def save_message(username, role, content, session_id=None, ipaddress=None):
     with sqlite3.connect(DB_FILE) as conn:
-        conn.execute(
-            'INSERT INTO messages (username, role, content) VALUES (?, ?, ?)',
-            (username, role, content)
+        cursor = conn.execute(
+            'INSERT INTO messages (username, role, content, session_id, ip_address) VALUES (?, ?, ?, ?, ?)',
+            (username, role, content, session_id, ipaddress)
         )
         conn.commit()
+        return cursor.lastrowid
+
 
 # retrieve chat history for a specific user
 # and return it as a list of dictionaries
 def get_messages(username):
     with sqlite3.connect(DB_FILE) as conn:
         cursor = conn.execute(
-            'SELECT role, content FROM messages WHERE username = ? ORDER BY timestamp ASC',
+            'SELECT id, role, content, feedback FROM messages WHERE username = ? ORDER BY timestamp ASC',
             (username,)
         )
-        return [{"role": row[0], "content": row[1]} for row in cursor.fetchall()]
+        return [{"id": row[0], "role": row[1], "content": row[2], "feedback": row[3]} for row in cursor.fetchall()] 
+
+def update_feedback(message_id, feedback):
+    with sqlite3.connect(DB_FILE) as conn:
+        conn.execute(
+            'UPDATE messages SET feedback = ? WHERE id = ?',
+            (feedback, message_id)
+        )
+        conn.commit()
+
+def on_feedback_change(message_id, fb_key):
+    feedback = st.session_state[fb_key]
+    update_feedback(message_id, feedback)
+
+def get_feedback(message_id):
+    with sqlite3.connect(DB_FILE) as conn:
+        cursor = conn.execute(
+            'SELECT feedback FROM messages WHERE id = ?',
+            (message_id,)
+        )
+        row = cursor.fetchone()
+        return row[0] if row else None
+
+

config.yaml.example

@@ -16,4 +16,13 @@ port: 8080
 system_prompt: ""
 query_rewriting_prompt: ""
 logo_pth: ""
-company_name: ""
+company_name: ""
+feedback_options: "thumbs" # thumbs, stars, or faces
+no_answer_message: "I don't have the answer to that question"
+nr_documents: 5
+# analytics
+analytics_model: "mistral-small-latest"
+analytics_prompt: "Given the following SQLite database schema: \n'''CREATE TABLE IF NOT EXISTS users (id integer PRIMARY KEY, username text NOT NULL UNIQUE, email text NOT NULL UNIQUE, type text DEFAULT 'guest', user_group text, email_verified integer DEFAULT 0, created_at DATETIME DEFAULT CURRENT_TIMESTAMP); CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT NOT NULL, role TEXT NOT NULL, content TEXT NOT NULL, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, feedback INTEGER DEFAULT NULL);''' where 'role' field contains 'user' for questions and 'assistant' for answers, 'feedback' field is 1 for positive feedback or thumb up, 0 for negative or thumb down \nGenerate a SQL query to answer the user question \nReturn ONLY the SQL query, nothing else and do not use 'start of week' or 'start of day', use alias for count field. User question: "
+dbpath: "users.db"
+landing_page: "https://aifaq.pro/"
+contact_page: ""

data_engine.py

@@ -0,0 +1,89 @@
+import os
+import pandas as pd
+import streamlit as st
+from mistralai import Mistral
+from utils import load_yaml_file
+import sqlite3
+
+config_data = load_yaml_file("config.yaml")
+
+def get_sql_query(question: str) -> str:
+    
+    prompt = config_data["analytics_prompt"] + question 
+
+    # Get API keys
+    mistral_api_key = os.getenv("MISTRALAI_API_KEY")
+    model = config_data["analytics_model"]
+
+    client = Mistral(api_key=mistral_api_key)
+
+    response = client.chat.complete(
+        model= model,
+        messages = [
+            {
+                "role": "user",
+                "content": prompt,
+            },
+        ]
+    )
+    sql_query = response.choices[0].message.content
+    sql_query = sql_query.replace("```sql", "").replace("```", "").strip()
+
+    return sql_query
+
+def run_sql_query(sql_query: str) -> pd.DataFrame:
+    # Run SQL query on SQLite DB and return results as DataFrame.
+    conn = sqlite3.connect(config_data["dbpath"])
+    try:
+        df = pd.read_sql(sql_query, conn)
+    except Exception as e:
+        st.error(f"SQL Error: {e}")
+        df = pd.DataFrame()
+    finally:
+        conn.close()
+    return df
+
+def load_analytics():
+    conn = sqlite3.connect(config_data["dbpath"])
+    try:
+        cursor = conn.execute("""
+            SELECT
+                id,
+                title,
+                sql_query,
+                options
+            FROM analytics
+            ORDER BY id;
+        """)
+        options = []
+        for row in cursor.fetchall():
+            option_list = [opt.strip() for opt in row[3].split(",") if opt.strip()]
+            options.append({
+                "key": row[0],
+                "title": row[1],
+                "sql_query": row[2],
+                "options": option_list
+            })
+    except Exception as e:
+        st.error(f"Error loading analytics options: {e}")
+        options = []
+    finally:
+        conn.close()
+    return options
+
+def get_analytics_query(query_id: int) -> str:
+    conn = sqlite3.connect(config_data["dbpath"])
+    try:
+        cursor = conn.execute("""
+            SELECT sql_query
+            FROM analytics
+            WHERE id = ?
+        """, (query_id,))
+        row = cursor.fetchone()
+        sql_query = row[0] if row else None
+    except Exception as e:
+        st.error(f"Error fetching query: {e}")
+        sql_query = None
+    finally:
+        conn.close()
+    return sql_query

database.py

@@ -1,34 +1,47 @@
 import sqlite3
+from utils import load_yaml_file
+
+# Read config data
+config_data = load_yaml_file("config.yaml")
 
 # This script creates a SQLite database to store user information.
 # It includes functions to create a connection to the database, create a table for users,
 # insert a new user, update user information, and retrieve user data.
 def create_connection():
     conn = None
     try:
-        conn = sqlite3.connect('users.db')
+        conn = sqlite3.connect(config_data["dbpath"])
     except sqlite3.Error as e:
         print(e)
     return conn
 
 def create_table(conn):
     try:
-        sql = '''CREATE TABLE IF NOT EXISTS users (
+        conn.execute('''
+            CREATE TABLE IF NOT EXISTS users (
                     id integer PRIMARY KEY,
                     username text NOT NULL UNIQUE,
                     email text NOT NULL UNIQUE,
                     type text DEFAULT 'guest',
                     user_group text,
-                    email_verified integer DEFAULT 0
-                );'''
-        conn.cursor().execute(sql)
+                    email_verified integer DEFAULT 0,
+                    created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+                );''')
+
+        cursor = conn.execute("PRAGMA table_info(users)")
+        existing_columns = [col[1] for col in cursor.fetchall()]
+
+        if "created_at" not in existing_columns:
+            conn.execute('ALTER TABLE users ADD COLUMN created_at DATETIME DEFAULT now')
+        
+        conn.commit()
     except sqlite3.Error as e:
         print(e)
 
 # This function creates a new user in the database.
 # It takes a connection object, username, email, and type as parameters.
 def insert_user(conn, username, email, type):
-    sql = '''INSERT INTO users(username, email, type) VALUES(?,?,?)'''
+    sql = '''INSERT INTO users(username, email, type, created_at) VALUES(?,?,?,CURRENT_TIMESTAMP)'''
     cur = conn.cursor()
     cur.execute(sql, (username, email, type))
     conn.commit()

homepage.py

@@ -8,20 +8,27 @@
 def gethomepage():
     markdown_string = f"""
 <div style="text-align: center;">
-  <img src={config_data["logo_pth"]} alt="AIFAQ logo" style="height: 110px">
-  <h1>AI Agent powered by <em>{config_data["company_name"]}</em></h1>
+  <img src={config_data["logo_pth"]} alt="AIFAQ logo" style="height: 60px">
+  <h3>AI Agent powered by <em>AIFAQ</em> (beta)</h3>
 </div>
 
-## Try for free
+---
+
+##### Try for free
 
 Here the [Official GitHub Repository](https://github.com/hyperledger-labs/aifaq)
 
-## Links and Resources
+---
+
+##### Links and Resources
+
+
+AIFAQ Inc. [website]({config_data["landing_page"]})
 
-AIFAQ Inc. [website](https://aifaqpro.wordpress.com/)
+---
 
-## {config_data["company_name"]}
+##### {config_data["company_name"]}
+This chatbot is a {config_data["company_name"]} conversational AI tool.
 
-This chatbot is a {config_data["company_name"]} conversational AI tool. Please, register or login:
 """
     return markdown_string