txt gpt

chatbot_legger.py

@@ -0,0 +1,156 @@
+import os
+from dotenv import load_dotenv
+from io import BytesIO
+from io import StringIO
+import sys
+import re
+from langchain.agents import create_csv_agent
+from src.modules.history import ChatHistory
+from src.modules.layout import Layout
+from src.modules.utils import Utilities
+from src.modules.sidebar import Sidebar
+import streamlit as st
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.chat_models import ChatOpenAI
+from langchain.chains import ConversationalRetrievalChain
+from langchain.vectorstores import FAISS
+
+
+# To be able to update the changes made to modules in localhost,
+# you can press the "r" key on the localhost page to refresh and reflect the changes made to the module files.
+def reload_module(module_name):
+    import importlib
+    import sys
+    if module_name in sys.modules:
+        importlib.reload(sys.modules[module_name])
+    return sys.modules[module_name]
+
+
+history_module = reload_module('src.modules.history')
+layout_module = reload_module('src.modules.layout')
+utils_module = reload_module('src.modules.utils')
+sidebar_module = reload_module('src.modules.sidebar')
+
+ChatHistory = history_module.ChatHistory
+Layout = layout_module.Layout
+Utilities = utils_module.Utilities
+Sidebar = sidebar_module.Sidebar
+
+
+def init():
+    load_dotenv()
+    st.set_page_config(layout="wide", page_icon="💬", page_title="ChatBot-Legger")
+
+
+def main():
+    init()
+    layout, sidebar, utils = Layout(), Sidebar(), Utilities()
+    sidebar.show_logo('assets/Images/colleen-logo.png')
+
+    layout.show_header_txt()
+    user_api_key = utils.load_api_key()
+
+
+    if not user_api_key:
+        layout.show_api_key_missing()
+    else:
+        os.environ["OPENAI_API_KEY"] = user_api_key
+        uploaded_file = utils.handle_upload_txt()
+
+        if uploaded_file:
+            history = ChatHistory()
+            sidebar.show_options()
+
+            uploaded_file_content = StringIO(uploaded_file.getvalue().decode("utf-8"))
+            string_data = uploaded_file_content.read()
+
+            # st.write(string_data)
+
+
+            try:
+                chatbot = utils.setup_chatbot_txt(
+                    uploaded_file, st.session_state["model"], st.session_state["temperature"]
+                )
+                st.session_state["chatbot"] = chatbot
+
+                # agent = create_csv_agent(ChatOpenAI(temperature=0),
+                #                          uploaded_file_content,
+                #                          verbose=True,
+                #                          max_iterations=15)
+
+                # embeddings = OpenAIEmbeddings()
+                # vectors = FAISS.from_documents([uploaded_file], embeddings)
+
+                # agent = ConversationalRetrievalChain.from_llm(
+                #     llm=ChatOpenAI(temperature=0.0, model_name='gpt-3.5-turbo', openai_api_key=user_api_key),
+                #     retriever=vectors.as_retriever())
+                # st.session_state['agent'] = agent
+                st.session_state['agent'] = chatbot
+
+                if st.session_state["ready"]:
+                    response_container, prompt_container = st.container(), st.container()
+
+                    with prompt_container:
+                        is_ready, user_input = layout.prompt_form()
+
+                        history.initialize(uploaded_file)
+                        if st.session_state["reset_chat"]:
+                            history.reset(uploaded_file)
+
+                        if is_ready:
+                            history.append("user", user_input)
+                            output = st.session_state["chatbot"].conversational_chat(user_input)
+
+                            history.append("assistant", output)
+                            # old_stdout = sys.stdout
+                            # sys.stdout = captured_output = StringIO()
+                            # agent_answer = chatbot.run(user_input)
+                            # sys.stdout = old_stdout
+                            # thoughts = captured_output.getvalue()
+                            #
+                            # cleaned_thoughts = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', thoughts)
+                            # cleaned_thoughts = re.sub(r'\[1m>', '', cleaned_thoughts)
+                            #
+                            # resp = cleaned_thoughts.split('Thought:')[-1].split('Final Answer')
+                            # thought = resp[0]
+                            # final_answer = resp[1].split('\n')[0].split(': ')[-1]
+                            # agent_answer_clean = '\n'.join([thought, final_answer])
+                            # full_answer = '\n'.join([output, agent_answer_clean])
+                            # history.append("assistant", full_answer)
+
+                    history.generate_messages(response_container)
+
+                    # if st.session_state["show_csv_agent"]:
+                    #     query = st.text_input(
+                    #         label="Use CSV agent for precise information about the structure of your csv file",
+                    #         placeholder="ex : how many rows in my file ?")
+                    #     if query != "":
+                    #         old_stdout = sys.stdout
+                    #         sys.stdout = captured_output = StringIO()
+                    #         agent = create_csv_agent(ChatOpenAI(temperature=0),
+                    #                                  uploaded_file_content,
+                    #                                  verbose=True,
+                    #                                  max_iterations=4)
+                    #
+                    #
+                    #         result = agent.run(query)
+                    #
+                    #         sys.stdout = old_stdout
+                    #         thoughts = captured_output.getvalue()
+                    #
+                    #         cleaned_thoughts = re.sub(r'\x1b\[[0-9;]*[a-zA-Z]', '', thoughts)
+                    #         cleaned_thoughts = re.sub(r'\[1m>', '', cleaned_thoughts)
+                    #
+                    #         with st.expander("Afficher les pensées de l'agent"):
+                    #             st.write(cleaned_thoughts)
+                    #
+                    #         st.write(result)
+
+            except Exception as e:
+                st.error(f"Error: {str(e)}")
+
+    sidebar.about()
+
+
+if __name__ == "__main__":
+    main()

pandasai_demo.py

@@ -0,0 +1,77 @@
+
+import streamlit as st
+import pandas as pd
+from pandasai import PandasAI
+from pandasai.llm.openai import OpenAI
+import matplotlib.pyplot as plt
+import toml
+#
+#
+key = 'sk-Sr1286CInNN1FxVqTOzu' + 'T3BlbkFJi1eo1gRQED5dSj4KXyHn'
+page_title = "Vanti chatBI"
+page_icon = ":money_with_wings:"  # emojis: https://www.webfx.com/tools/emoji-cheat-sheet/
+
+st.set_page_config(page_title=page_title, page_icon=page_icon, layout="wide")
+primaryColor = toml.load(".streamlit/config.toml")['theme']['primaryColor']
+style_description = f"""
+    <style>
+        div.stButton > button:first-child {{ border: 2px solid {primaryColor}; border-radius:10px 10px 10px 10px; }}
+        div.stButton > button:hover {{ background-color: {primaryColor}; color:#000000;}}
+        footer {{ visibility: hidden;}}
+        # header {{ visibility: hidden;}}
+    <style>
+"""
+st.markdown(style_description, unsafe_allow_html=True)
+
+st.title("pandas-ai streamlit interface")
+
+st.write("A demo interface for [PandasAI](https://github.com/gventuri/pandas-ai)")
+st.write(
+    "Looking for an example *.csv-file?, check [here](https://gist.github.com/netj/8836201)."
+)
+with st.sidebar:
+    st.image('assets/Images/Vanti - Main Logo@4x copy.png')
+    if "openai_key" not in st.session_state:
+        with st.form("API key"):
+            key = st.text_input("OpenAI Key", value="", type="password")
+            if st.form_submit_button("Submit"):
+                st.session_state.openai_key = key
+                st.session_state.prompt_history = []
+                st.session_state.df = None
+
+if "openai_key" in st.session_state:
+    if st.session_state.df is None:
+        uploaded_file = st.file_uploader(
+            "Choose a CSV file. This should be in long format (one datapoint per row).",
+            type="csv",
+        )
+        if uploaded_file is not None:
+            df = pd.read_csv(uploaded_file)
+            st.session_state.df = df
+
+    with st.form("Question"):
+        question = st.text_input("Question", value="", type="default")
+        submitted = st.form_submit_button("Submit")
+        if submitted:
+            with st.spinner():
+                llm = OpenAI(api_token=st.session_state.openai_key)
+                pandas_ai = PandasAI(llm)
+                x = pandas_ai.run(st.session_state.df, prompt=question)
+
+                fig = plt.gcf()
+                if fig.get_axes():
+                    st.pyplot(fig)
+                st.write(x)
+                st.session_state.prompt_history.append(question)
+
+    if st.session_state.df is not None:
+        st.subheader("Current dataframe:")
+        st.write(st.session_state.df)
+
+    st.subheader("Prompt history:")
+    st.write(st.session_state.prompt_history)
+
+
+if st.button("Clear"):
+    st.session_state.prompt_history = []
+    st.session_state.df = None

src/modules/chatbot.py

@@ -4,6 +4,48 @@ from langchain.chains import ConversationalRetrievalChain
 from langchain.prompts.prompt import PromptTemplate
 
 
+class Chatbot_txt:
+    _template = """Given the following conversation and a follow-up question, rephrase the follow-up question to be a standalone question.
+    Chat History:
+    {chat_history}
+    Follow-up entry: {question}
+    Standalone question:"""
+
+    CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+
+    qa_template = """"You are an AI conversational assistant to answer questions based on a context.
+    You are given data from a txt file and a question, you must help the user find the information they need. 
+    Your answers should be friendly, in the same language.
+    question: {question}
+    =========
+    context: {context}
+    =======
+    """
+
+    QA_PROMPT = PromptTemplate(template=qa_template, input_variables=["question", "context"])
+
+    def __init__(self, model_name, temperature, vectors):
+        self.model_name = model_name
+        self.temperature = temperature
+        self.vectors = vectors
+
+    def conversational_chat(self, query):
+        """
+        Starts a conversational chat with a model via Langchain
+        """
+        chain = ConversationalRetrievalChain.from_llm(
+            llm=ChatOpenAI(model_name=self.model_name, temperature=self.temperature),
+            condense_question_prompt=self.CONDENSE_QUESTION_PROMPT,
+            qa_prompt=self.QA_PROMPT,
+            retriever=self.vectors.as_retriever(),
+        )
+        result = chain({"question": query, "chat_history": st.session_state["history"]})
+
+        st.session_state["history"].append((query, result["answer"]))
+
+        return result["answer"]
+
+
 class Chatbot:
     _template = """Given the following conversation and a follow-up question, rephrase the follow-up question to be a standalone question.
     Chat History:

src/modules/embedder.py

@@ -4,8 +4,66 @@ import tempfile
 from langchain.document_loaders.csv_loader import CSVLoader
 from langchain.vectorstores import FAISS
 from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.document_loaders import TextLoader
+from langchain.text_splitter import CharacterTextSplitter
 
 
+class Embedder_txt:
+    def __init__(self):
+        self.PATH = "embeddings"
+        self.createEmbeddingsDir()
+
+    def createEmbeddingsDir(self):
+        """
+        Creates a directory to store the embeddings vectors
+        """
+        if not os.path.exists(self.PATH):
+            os.mkdir(self.PATH)
+
+    def storeDocEmbeds(self, file, filename):
+        """
+        Stores document embeddings using Langchain and FAISS
+        """
+        # Write the uploaded file to a temporary file
+        with tempfile.NamedTemporaryFile(mode="wb", delete=False) as tmp_file:
+            tmp_file.write(file)
+            tmp_file_path = tmp_file.name
+
+        # Load the data from the file using Langchain
+        # loader = CSVLoader(file_path=tmp_file_path, encoding="utf-8")
+        documents = []
+        loader = TextLoader(file_path=tmp_file_path)
+        documents.extend(loader.load())
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        data = loader.load_and_split()
+        texts = text_splitter.split_documents(documents)
+
+        # Create an embeddings object using Langchain
+        embeddings = OpenAIEmbeddings()
+
+        # Store the embeddings vectors using FAISS
+        vectors = FAISS.from_documents(texts, embeddings)
+        os.remove(tmp_file_path)
+
+        # Save the vectors to a pickle file
+        with open(f"{self.PATH}/{filename}.pkl", "wb") as f:
+            pickle.dump(vectors, f)
+
+    def getDocEmbeds(self, file, filename):
+        """
+        Retrieves document embeddings
+        """
+        # Check if embeddings vectors have already been stored in a pickle file
+        if not os.path.isfile(f"{self.PATH}/{filename}.pkl"):
+            # If not, store the vectors using the storeDocEmbeds function
+            self.storeDocEmbeds(file, filename)
+
+        # Load the vectors from the pickle file
+        with open(f"{self.PATH}/{filename}.pkl", "rb") as f:
+            vectors = pickle.load(f)
+
+        return vectors
+
 class Embedder:
     def __init__(self):
         self.PATH = "embeddings"

src/modules/layout.py

@@ -3,6 +3,18 @@ import streamlit as st
 
 class Layout:
     
+    def show_header_txt(self):
+        """
+        Displays the header of the app
+        """
+        # st.image('assets/Images/colleen-logo.png', width=400)
+        st.markdown(
+            """
+            <h1 style='text-align: center;'>LedgerGPT by Colleen.AI, Talk with your ledger data! 💬</h1>
+            """,
+            unsafe_allow_html=True,
+        )
+
     def show_header(self):
         """
         Displays the header of the app

src/modules/sidebar.py

@@ -8,6 +8,10 @@ class Sidebar:
     TEMPERATURE_DEFAULT_VALUE = 0.0
     TEMPERATURE_STEP = 0.01
 
+    @staticmethod
+    def show_logo(path):
+        st.sidebar.image(path)
+
     @staticmethod
     def about():
         about = st.sidebar.expander("About 🤖")

src/modules/utils.py

@@ -1,9 +1,11 @@
 import os
 import pandas as pd
 import streamlit as st
+from io import StringIO
 
-from src.modules.chatbot import Chatbot
-from src.modules.embedder import Embedder
+
+from src.modules.chatbot import Chatbot_txt, Chatbot
+from src.modules.embedder import Embedder_txt, Embedder
 
 
 class Utilities:
@@ -24,6 +26,29 @@ class Utilities:
                 st.sidebar.success("API key loaded", icon="🚀")
         return user_api_key
 
+    @staticmethod
+    def handle_upload_txt():
+        """
+        Handles the file upload and displays the uploaded file
+        """
+        uploaded_file = st.sidebar.file_uploader("upload", type="txt", label_visibility="collapsed")
+        if uploaded_file is not None:
+
+            def show_user_file(uploaded_file):
+                file_container = st.expander("Your TXT file :")
+                uploaded_file_content = StringIO(uploaded_file.getvalue().decode("utf-8"))
+                string_data = uploaded_file_content.read()
+                file_container.write(string_data)
+
+            show_user_file(uploaded_file)
+        else:
+            st.sidebar.info(
+                "👆 Upload your TXT file to get started, "
+                # "sample for try : [fishfry-locations.csv](https://drive.google.com/file/d/1TpP3thVnTcDO1_lGSh99EKH2iF3GDE7_/view?usp=sharing)"
+            )
+            st.session_state["reset_chat"] = True
+        return uploaded_file
+
     @staticmethod
     def handle_upload():
         """
@@ -31,14 +56,12 @@ class Utilities:
         """
         uploaded_file = st.sidebar.file_uploader("upload", type="csv", label_visibility="collapsed")
         if uploaded_file is not None:
-            
 
             def show_user_file(uploaded_file):
                 file_container = st.expander("Your CSV file :")
                 shows = pd.read_csv(uploaded_file)
                 uploaded_file.seek(0)
                 file_container.write(shows)
-             
 
             show_user_file(uploaded_file)
         else:
@@ -49,12 +72,27 @@ class Utilities:
             st.session_state["reset_chat"] = True
         return uploaded_file
 
+    @staticmethod
+    def setup_chatbot_txt(uploaded_file, model, temperature):
+        """
+        Sets up the chatbot with the uploaded file, model, and temperature
+        """
+        embeds = Embedder_txt()
+        with st.spinner("Processing..."):
+            uploaded_file.seek(0)
+            file = uploaded_file.read()
+            vectors = embeds.getDocEmbeds(file, uploaded_file.name)
+            chatbot = Chatbot(model, temperature, vectors)
+        st.session_state["ready"] = True
+        return chatbot
+
+
     @staticmethod
     def setup_chatbot(uploaded_file, model, temperature):
         """
         Sets up the chatbot with the uploaded file, model, and temperature
         """
-        embeds = Embedder()
+        embeds = Embedder_txt()
         with st.spinner("Processing..."):
             uploaded_file.seek(0)
             file = uploaded_file.read()