Update app.py

app.py

@@ -1,36 +1,64 @@
 import streamlit as st
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.pydantic_v1 import BaseModel, Field
-from typing import List, Optional
-from langchain_core.prompts import ChatPromptTemplate
-import warnings
-import json
-from langchain_chroma import Chroma
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnablePassthrough
-from langchain_core.documents import Document
-import os
-from datetime import datetime
-from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-from langchain_core.runnables import RunnableParallel
-from langchain_groq import ChatGroq
-from langchain_community.chat_message_histories import SQLChatMessageHistory
-from langchain_core.runnables import ConfigurableFieldSpec
-from langchain_core.messages import HumanMessage
-from langchain_core.runnables.history import RunnableWithMessageHistory
-from langchain_core.documents import Document
-from langchain_core.runnables import RunnablePassthrough
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_community.utilities import SQLDatabase
-import pytz
-import sqlite3
-import tqdm
-
-
-# Database setup
+
+
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="langchain_community")
+
+tagging_prompt = ChatPromptTemplate.from_template(
+    """
+    Extract the desired information from the following passage.
+
+    Only extract the properties mentioned in the 'Classification' function.
+
+    Training data for reference:
+    {traning_data}
+
+    Passage:
+    {input}
+    """
+)
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            "You are an expert extraction algorithm. "
+            "Only extract relevant information from the text. "
+            "If you do not know the value of an attribute asked to extract, "
+            "return null for the attribute's value.",
+        ),
+        ("human", "{text}"),
+    ]
+)
+
+os.environ["GROQ_API_KEY"] = "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"
+
+class Classification(BaseModel):
+    sentiment: str = Field(..., enum=["set reminder", "update reminder", "check reminder", "remove reminder", "other content"])
+
+llm = ChatGroq(model="llama-3.1-70b-versatile").with_structured_output(Classification)
+llm_st = ChatGroq(model="llama-3.1-70b-versatile", temperature=0)
+llm_chat = ChatGroq(model="llama-3.1-70b-versatile")
+
+class SetReminder(BaseModel):
+    reason: str = Field(..., description="Reason of the reminder")
+    time: str = Field(..., description="What time is the reminder set for?")
+    date: str = Field(..., description="What date is the reminder set for?")
+
+tagging_chain = tagging_prompt | llm
+runnable = prompt | llm_st.with_structured_output(schema=SetReminder)
+
+
+def get_current_time():
+    adelaide_tz = pytz.timezone('Australia/Adelaide')
+    now = datetime.now(adelaide_tz)
+    return now.strftime("%I:%M:%S %p")  # Returns time in HH:MM:SS format
+
+def get_date():
+    adelaide_tz = pytz.timezone('Australia/Adelaide')
+    current_date = datetime.now(adelaide_tz).strftime("%Y-%m-%d")
+    return current_date
+
+
 def create_reminders_table():
     sql_statement = """
         CREATE TABLE IF NOT EXISTS reminders (
@@ -40,26 +68,36 @@ def create_reminders_table():
             reason TEXT NOT NULL
         );
     """
+
     try:
         with sqlite3.connect('reminders.db') as conn:
             cursor = conn.cursor()
             cursor.execute(sql_statement)
             conn.commit()
+            print("sucess")
     except sqlite3.Error as e:
-        st.error(f"An error occurred: {e}")
+        print(e)
 
-# Helper functions
-def get_current_time():
-    adelaide_tz = pytz.timezone('Australia/Adelaide')
-    now = datetime.now(adelaide_tz)
-    return now.strftime("%I:%M:%S %p")  # Returns time in HH:MM:SS format
+create_reminders_table()
+
+
+def list_reminders():
+    sql_statement = "SELECT * FROM reminders;"
+
+    try:
+        with sqlite3.connect('reminders.db') as conn:
+            cursor = conn.cursor()
+            cursor.execute(sql_statement)
+            rows = cursor.fetchall()
+            for row in rows:
+                print(row)
+    except sqlite3.Error as e:
+        print(f"Error: {e}")
 
-def get_date():
-    adelaide_tz = pytz.timezone('Australia/Adelaide')
-    return datetime.now(adelaide_tz).strftime("%Y-%m-%d")
 
 def get_reminders():
     sql_statement = "SELECT * FROM reminders;"
+
     try:
         with sqlite3.connect('reminders.db') as conn:
             cursor = conn.cursor()
@@ -67,25 +105,70 @@ def get_reminders():
             rows = cursor.fetchall()
             return rows
     except sqlite3.Error as e:
-        st.error(f"An error occurred: {e}")
+        print(f"Error: {e}")
         return []
 
-
-
 def format_reminders_for_context(reminders):
     context = ""
     for reminder in reminders:
         context += f"ID: {reminder[0]}, Time: {reminder[1]}, Date: {reminder[2]}, Reason: {reminder[3]}\n"
     return context
 
-# Define models and prompts
-class Classification(BaseModel):
-    sentiment: str = Field(..., enum=["set reminder", "update reminder", "check reminder", "remove reminder", "other content"])
-
-llm = ChatGroq(model="llama-3.1-70b-versatile").with_structured_output(Classification)
-llm_st = ChatGroq(model="llama-3.1-70b-versatile", temperature=0)
-llm_chat = ChatGroq(model="llama-3.1-70b-versatile")
-
+def get_session_history(user_id: str, conversation_id: str):
+    return SQLChatMessageHistory(f"{user_id}--{conversation_id}", "sqlite:///memory.db")
+
+chatting_prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            "Your are a friendly assistant Ai! Today date is {today_date} and Time now is {time_now}",
+        ),
+        MessagesPlaceholder(variable_name="history"),
+        ("human", "{input}"),
+    ]
+)
+
+runnable_chat = chatting_prompt | llm_chat
+
+
+with_message_history = RunnableWithMessageHistory(
+    runnable_chat,
+    get_session_history,
+    input_messages_key="input",
+    history_messages_key="history",
+    history_factory_config=[
+        ConfigurableFieldSpec(
+            id="user_id",
+            annotation=str,
+            name="User ID", #user_id
+            description="Unique identifier for the user.",
+            default="",
+            is_shared=True,
+        ),
+        ConfigurableFieldSpec(
+            id="conversation_id",
+            annotation=str,
+            name="Conversation ID", #session
+            description="Unique identifier for the conversation.",
+            default="",
+            is_shared=True,
+        ),
+    ],
+)
+
+
+def get_ai_response(user_input):
+    response = ""
+    try:
+        for s in with_message_history.stream(
+            {"input": user_input, "time_now": get_current_time(), "today_date": get_date()},
+            config={"user_id": "123", "conversation_id": "1"}
+        ):
+            response += s.content
+    except Exception as e:
+        error_message = f"Error: {e}"
+        return response, error_message
+    return response, None
 
 message_max = """
 Answer this question using the database provided only.
@@ -186,84 +269,88 @@ vectorstore = Chroma.from_documents(documents=splits, embedding=HuggingFaceEmbed
 # Set up the retriever to fetch relevant phrases based on the user's query
 retriever = vectorstore.as_retriever()
 
-# Define the main function to handle user interaction
+
+
 def handle_user_input(user_input):
     time_now = get_current_time()
     current_date = get_date()
 
     sentimenttocheck = ""
-    try:
-        res = tagging_chain.invoke({"input": user_input, "traning_data": retriever})
-        sentimenttocheck = res.sentiment
-    except Exception as e:
-        st.error(f"An error occurred: {e}")
-        return None
+    res = tagging_chain.invoke({"input": user_input, "traning_data": retriever})
+    sentimenttocheck += res.sentiment
 
     if sentimenttocheck == "set reminder":
-        reminders = get_reminders()
-        database = format_reminders_for_context(reminders)
+        reminders_thr = get_reminders()
+        database_thr = format_reminders_for_context(reminders_thr)
         new_remind = "" 
-        for new_reminder in rag_chain_tt.stream({"question": user_input, "context": database, "date_tt": current_date, "current_time": time_now}):
+        for new_reminder in rag_chain_tt.stream({"question": user_input, "context": database_thr, "date_tt": get_date(), "current_time": time_now}):
             new_remind += new_reminder.content
-        
+        st.write(f"New reminder: {new_remind}")
         if new_remind == "repeated_reminder":
-            st.info("Reminder already existed!")
+            st.write("Reminder already existed!")
         else:
             try:
                 with sqlite3.connect('reminders.db') as conn:
                     cursor = conn.cursor()
+
+                    # Execute the update query
                     cursor.execute(new_remind)
                     conn.commit()
+
+                # Check if the update was successful
                 if cursor.rowcount > 0:
-                    st.success("New reminder created.")
+                    st.write("New reminder created.")
                 else:
-                    st.warning("No reminder created, Errors occurred.")
+                    st.write("No reminder created, errors occurred.")
+
             except sqlite3.Error as e:
-                st.error(f"An error occurred while creating the reminder: {e}")
+                st.write(f"An error occurred while updating the reminder: {e}")
 
     elif sentimenttocheck == "update reminder":
-        reminders = get_reminders()
-        database = format_reminders_for_context(reminders)
-        updated_remind = ""
-        for updated_cont in rag_chaining.stream({"question": user_input, "context": database, "date_tt": current_date}):
+        reminders_sec = get_reminders()
+        database_sec = format_reminders_for_context(reminders_sec)
+        updated_remind = "" 
+        for updated_cont in rag_chaining.stream({"question": user_input, "context": database_sec, "date_tt": get_date()}):
             updated_remind += updated_cont.content
+        st.write(f"Database: {updated_remind}")
         if updated_remind == "reminder_x":
-            st.info("No reminder found to change!")
+            st.write("No reminder found to change!")
         else:
             try:
                 with sqlite3.connect('reminders.db') as conn:
                     cursor = conn.cursor()
+
+                    # Execute the update query
                     cursor.execute(updated_remind)
                     conn.commit()
+
+                # Check if the update was successful
                 if cursor.rowcount > 0:
-                    st.success("Reminder updated successfully.")
+                    st.write("Reminder updated successfully.")
                 else:
-                    st.warning("No reminder found to update with the given details.")
+                    st.write("No reminder found to update with the given details.")
+
             except sqlite3.Error as e:
-                st.error(f"An error occurred while updating the reminder: {e}")
+                st.write(f"An error occurred while updating the reminder: {e}")
 
     elif sentimenttocheck == "check reminder":
         reminders = get_reminders()
         database = format_reminders_for_context(reminders)
         response_max = ""
-        for max in rag_chain.stream({"question": user_input, "context": database, "date_tt": current_date}):
+        for max in rag_chain.stream({"question": user_input, "context": database, "date_tt": get_date()}):
             response_max += max.content
-        st.info(f"Reminder details: {response_max}")
+        st.write(f"Database remind: {response_max}")
 
     elif sentimenttocheck == "remove reminder":
-        st.info("Remove Reminder functionality needs to be implemented.")
+        st.write("Remove Reminder")
+
     else:
         ai_response, error_message = get_ai_response(user_input)
-        if error_message:
-            st.error(error_message)
-        else:
-            st.info(ai_response)
+        st.write(f"{ai_response}")
 
 # Streamlit app layout
 st.title("🦜🔗 Reminder AI")
 
-create_reminders_table()
-
 with st.form("reminder_form"):
     user_input = st.text_area("Enter your request:")
     submit_button = st.form_submit_button("Submit")
@@ -271,11 +358,3 @@ with st.form("reminder_form"):
     if submit_button and user_input:
         handle_user_input(user_input)
 
-st.write("Existing reminders:")
-reminders_list = get_reminders()
-if reminders_list:
-    for reminder in reminders_list:
-        st.write(f"ID: {reminder[0]}, Time: {reminder[1]}, Date: {reminder[2]}, Reason: {reminder[3]}")
-else:
-    st.write("No reminders found.")
-