app.py

import streamlit as st
import sqlite3
from hashlib import sha256
import streamlit as st
from datetime import datetime
from langchain_community.embeddings import LlamaCppEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain_community.document_loaders import TextLoader
from langchain_community.vectorstores import FAISS
from langchain.embeddings import HuggingFaceEmbeddings 
from langchain.chains.llm import LLMChain
from langchain_community.llms import LlamaCpp
from langchain.chains import LLMChain
from langchain_community.llms import OpenAI
from langchain_core.prompts import PromptTemplate, ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough
from langchain_core.documents import Document
from langchain.chains import create_retrieval_chain
from langchain.chains.combine_documents import create_stuff_documents_chain


# Create a SQLite database named 'user_credentials.db'. If it already exists, connect to it.
# This database is used for storing user credentials.
conn = sqlite3.connect("user_credentials.db")

# Create a cursor object using the connection. 
# The cursor is used to execute SQL commands.
cursor = conn.cursor()

# Execute an SQL command using the cursor. 
# This command attempts to create a new table named 'users' if it doesn't already exist.
# The table is designed to store usernames and passwords.
# It has two columns: 'username' and 'password'.
# 'username' is of type TEXT and is set as the PRIMARY KEY, ensuring that each username is unique.
# 'password' is also of type TEXT to store the password associated with each username.
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        username TEXT PRIMARY KEY,
        password TEXT
    )
''')

# Commit the changes made by the cursor.execute command to the database.
# This ensures that the creation of the table is saved in the database.
conn.commit()


# Check if the embeddings model is not already stored in Streamlit's session state
if 'embeddings' not in st.session_state:
    # Initialize and store the embeddings model in session state for efficient reuse
    st.session_state.embeddings = HuggingFaceEmbeddings(
        model_name="sentence-transformers/all-MiniLM-L6-v2",  # Specify the model name to use
        model_kwargs={"device": "cpu"},  # Force the model to run on CPU
    )


def get_similar_docs(query):
    # Load the FAISS index from local storage using the embeddings model stored in session state
    db = FAISS.load_local('faiss_index', st.session_state.embeddings)
    # Perform a similarity search in the FAISS database for the given query, returning top 100 similar documents with scores
    docs = db.similarity_search_with_score(query, 100)
    # Return the list of similar documents and their similarity scores
    return docs

def format_docs(docs):
    # Join the page content of each document in docs with a space, and return the concatenated string
    return " ".join(doc.page_content for doc in docs)

def get_advice_from_llm(query):
    # Load the FAISS index and initialize it with embeddings from session state for document retrieval
    db = FAISS.load_local('faiss_index', st.session_state.embeddings)
    # Convert the FAISS index into a retriever for fetching documents based on queries
    retriever = db.as_retriever()
    # Initialize the LlamaCpp model with specified model path and context size
    llm = LlamaCpp(model_path="./tinyllama-1.1b-chat-v1.0.Q8_0.gguf", n_ctx=2048)
    # Create a chat history string from session state for inclusion in the prompt template
    chat_history_str = "\n".join(["" + entry[0] + entry[1] + "\n" for entry in st.session_state['chat_history']])
    # Define the prompt template with placeholders for dynamic context and user input
    template = """" 
        system
        {context}""" + \
        chat_history_str +\
        """
        user{input}

        assistant
       """    
    # Initialize a PromptTemplate with variables for dynamic insertion into the template
    prompt = PromptTemplate(input_variables=["input", "context"], template=template)
    # Chain the LlamaCpp model with the prompt for generating responses
    llm_chain = LLMChain(llm=llm, prompt=prompt)
    # Define the RAG chain combining retriever and LLM chain for generating advice based on the query
    rag_chain = ({"context": retriever | format_docs, "input": RunnablePassthrough()} | llm_chain)
    # Invoke the RAG chain with the user query to get advice
    answer = rag_chain.invoke(query)
    # Return the generated advice
    return answer


def vectordb_entry():
    # Load text documents from a specified file
    loader = TextLoader("./output.txt")
    documents = loader.load()
    # Split loaded documents into smaller chunks for vectorization
    text_splitter = CharacterTextSplitter(chunk_size=100, chunk_overlap=10)
    docs = text_splitter.split_documents(documents)
    # Load or create a FAISS vector database using embeddings from session state
    db = FAISS.load_local('faiss_index', st.session_state.embeddings)
    # Add the document chunks to the FAISS database
    db.add_documents(docs)
    # Save the updated database locally
    db.save_local('faiss_index')


def save_into_text_file(file_path, text):
    # Open the specified file path for writing and save the provided text string into it
    with open(file_path, 'w') as file:
        file.write(text)
    # Print a confirmation message indicating where the text was saved
    print(f"String saved to {file_path}")


def journal():
    # Create a container to display chat messages with a specified height
    messages = st.container(height=600)
    # Create a chat input box for users to enter their queries
    query = st.chat_input("Need some advice?")

    # Initialize an input_key in session state if it doesn't exist, to track input changes
    if 'input_key' not in st.session_state:
        st.session_state.input_key = 0

    # Initialize chat_history in session state if it doesn't exist, to store chat interactions
    if 'chat_history' not in st.session_state:
        st.session_state.chat_history = []
    
    # If the user has entered a query
    if query:
        # Get advice from the language model for the given query
        answer = get_advice_from_llm(query)
        # Append the user's query and the model's response to the chat history
        st.session_state.chat_history.append(("user", query))
        st.session_state.chat_history.append(("assistant", answer['text']))
        # Increment the input_key to trigger updates
        st.session_state.input_key += 1

    # If there is chat history, display it in the messages container
    if 'chat_history' in st.session_state and st.session_state.chat_history:
        for speaker, message in st.session_state.chat_history:
            # Assign a display name based on the speaker
            who = "You" if speaker == "user" else "JournaLLM"
            # Display each message in the chat container
            messages.chat_message(speaker).write(who + ': '+ str(message))

    # Provide a button to reset the chat
    if st.button('Reset Chat'):
        # Clear the chat history
        st.session_state.chat_history = []
        # Increment the input_key to trigger updates
        st.session_state.input_key += 1
        # Rerun the Streamlit app to reflect changes
        st.experimental_rerun()



# Function to hash passwords
def hash_password(password):
    return sha256(password.encode()).hexdigest()

# Function to check login credentials
def authenticate(username, password):
    hashed_password = hash_password(password)
    cursor.execute("SELECT * FROM users WHERE username=? AND password=?", (username, hashed_password))
    return cursor.fetchone() is not None

# Function to add a new user to the database
def add_user(username, password):
    hashed_password = hash_password(password)
    try:
        cursor.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, hashed_password))
        conn.commit()
        return True  # User added successfully
    except sqlite3.IntegrityError:
        return False  # Username already exists

# Streamlit Login Page
def login_page():
    st.title("Login Page")
    
    st.session_state['username'] = st.text_input("Username:")
    st.session_state['password'] = st.text_input("Password:", type="password")
    
    if st.button("Login"):
        if not st.session_state['username'] or not st.session_state['password']:
            st.error("Both username and password are required.")
        elif authenticate(st.session_state['username'], st.session_state['password']):
            st.success("Login successful!")
        else:
            st.error("Invalid credentials. Please try again.")

# Streamlit Signup Page
def signup_page():
    st.title("Signup Page")
    new_username = st.text_input("New Username:")
    new_password = st.text_input("New Password:", type="password")
    
    if st.button("Signup"):
        if not new_username or not new_password:
            st.error("Both username and password are required.")
        else:
            result = add_user(new_username, new_password)
            if result:
                st.success("Signup successful! You can now login.")
                #create db
            else:
                st.error("Username already exists. Please choose a different username.") 


def entry():
    st.title('JournaLLM')  # Set the title of the Streamlit app
    # Display a welcome message to the user
    st.write('Welcome to JournaLLM, your personal space for mindful reflection and goal tracking! This app is designed to help you seamlessly capture your daily thoughts, set meaningful goals, and track your progress.')
    
    # Initialize an input key in session state if it's not present, to track submissions
    if 'input_key' not in st.session_state:
        st.session_state.input_key = 0
    
    file_path = "output.txt"  # Define the path for the output file where entries will be saved

    # Create a text area in the app for users to write their journal entry
    text = st.text_area("Today's Entry")
  
    # Prepare a template with questions for the journal entry, including the current date
    template = f'''Question: What happened on {datetime.today().strftime("%B %d, %Y")}? 
    How did I feel on {datetime.today().strftime("%B %d, %Y")}? 
    What were the events that happened on {datetime.today().strftime("%B %d, %Y")}? 
    Describe your day, {datetime.today().strftime("%B %d, %Y")}. \n Answer: '''
    
    text = template + text  # Append the user's text to the template

    # Save the journal entry to a file and update the vector database when the 'Pen down' button is pressed
    if st.button('Pen down') and text:
        save_into_text_file(file_path, text)  # Call function to save the text into the specified file
        vectordb_entry()  # Call function to add the entry to the vector database
        st.write('Entry saved')  # Confirm the entry has been saved
        st.write(text)  # Display the saved text to the user
        st.session_state.input_key += 1  # Increment the session state's input key to track changes



# Main Streamlit App
def main():
    st.set_page_config(layout="wide")
    st.sidebar.title("Navigation")
    page = st.sidebar.radio("Go to", ["Login", "Signup","Entry","Advice"])

    if page == "Login":
        login_page()
    elif page == "Signup":
        signup_page()
    elif page == "Entry":
        if st.session_state.username == "":
            st.write('Please login to continue.')
        else:
            st.write(f"Logged in as {st.session_state.username}")
            entry()
    elif page == "Advice":
        if st.session_state.username == "":
            st.write('Please login to continue.')
        else:
            st.write(f"Logged in as {st.session_state.username}")
            journal()

if __name__ == "__main__":
    main()