added langchain to ui

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.*pdf filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,25 +1,17 @@
 # https://docs.streamlit.io/knowledge-base/tutorials/build-conversational-apps
 
 import os
-import time
 
 import openai
 import requests
 import streamlit as st
 
-from models import bloom
 from utils.util import *
 
-# from streamlit_chat import message
+st.set_page_config(page_title="RegBotBeta", page_icon="📜🤖")
 
-
-st.title("Welcome to RegBotBeta")
-st.header("Powered by `LlamaIndex🦙` and `OpenAI API`")
-
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-
-index = None
+st.title("Welcome to RegBotBeta2.0")
+st.header("Powered by `LlamaIndex🦙`, `Langchain🦜🔗 ` and `OpenAI API`")
 
 api_key = st.text_input("Enter your OpenAI API key here:", type="password")
 
@@ -31,57 +23,8 @@ if api_key:
         st.info("Success")
         os.environ["OPENAI_API_KEY"] = api_key
         openai.api_key = api_key
-        with st.spinner("Initializing vector index ..."):
-            index = create_index(bloom)
-
-st.write("---")
-if index:
-    # Display chat messages from history on app rerun
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-
-    if prompt := st.chat_input("Say something"):
-        # Display user message in chat message container
-        st.chat_message("user").markdown(prompt)
-
-        # Add user message to chat history
-        st.session_state.messages.append({"role": "user", "content": prompt})
-
-        with st.spinner("Processing your query..."):
-            bot_response = get_response(index, prompt)
-
-        print("bot: ", bot_response)
-
-        # Display assistant response in chat message container
-        with st.chat_message("assistant"):
-            message_placeholder = st.empty()
-            full_response = ""
-
-            # simulate the chatbot "thinking" before responding
-            # (or stream its response)
-            for chunk in bot_response.split():
-                full_response += chunk + " "
-                time.sleep(0.05)
-
-                # add a blinking cursor to simulate typing
-                message_placeholder.markdown(full_response + "▌")
-
-            message_placeholder.markdown(full_response)
-            # st.markdown(response)
 
-        # Add assistant response to chat history
-        st.session_state.messages.append(
-            {"role": "assistant", "content": full_response}
-        )
+        if "openai_api_key" not in st.session_state:
+            st.session_state.openai_api_key = ""
 
-        # Scroll to the bottom of the chat container
-        # st.markdown(
-        #     """
-        #     <script>
-        #     const chatContainer = document.getElementsByClassName("css-1n76uvr")[0];
-        #     chatContainer.scrollTop = chatContainer.scrollHeight;
-        #     </script>
-        #     """,
-        #     unsafe_allow_html=True,
-        # )
+        st.session_state.openai_api_key = api_key

models/bloom.py

@@ -1,107 +0,0 @@
-import os
-import pickle
-from json import dumps, loads
-
-import numpy as np
-import openai
-import pandas as pd
-from dotenv import load_dotenv
-from huggingface_hub import HfFileSystem
-from llama_index import (
-    Document,
-    GPTVectorStoreIndex,
-    LLMPredictor,
-    PromptHelper,
-    ServiceContext,
-    StorageContext,
-    load_index_from_storage,
-)
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-
-from utils.customLLM import CustomLLM
-
-load_dotenv()
-openai.api_key = os.getenv("OPENAI_API_KEY")
-fs = HfFileSystem()
-
-# get model
-# model_name = "bigscience/bloom-560m"
-# tokenizer = AutoTokenizer.from_pretrained(model_name)
-# model = AutoModelForCausalLM.from_pretrained(model_name, config='T5Config')
-
-# define prompt helper
-# set maximum input size
-context_window = 2048
-# set number of output tokens
-num_output = 525
-# set maximum chunk overlap
-chunk_overlap_ratio = 0.2
-prompt_helper = PromptHelper(context_window, num_output, chunk_overlap_ratio)
-
-# create a pipeline
-# pl = pipeline(
-#     model=model,
-#     tokenizer=tokenizer,
-#     task="text-generation",
-#     # device=0, # GPU device number
-#     # max_length=512,
-#     do_sample=True,
-#     top_p=0.95,
-#     top_k=50,
-#     temperature=0.7
-# )
-
-# define llm
-llm_predictor = LLMPredictor(llm=CustomLLM())
-service_context = ServiceContext.from_defaults(
-    llm_predictor=llm_predictor, prompt_helper=prompt_helper
-)
-
-
-def prepare_data(file_path: str):
-    df = pd.read_json(file_path)
-    df = df.replace(to_replace="", value=np.nan).dropna(axis=0)  # remove null values
-
-    parsed = loads(df.to_json(orient="records"))
-
-    documents = []
-    for item in parsed:
-        document = Document(
-            text=item["paragraphText"],
-            doc_id=item["_id"]["$oid"],
-            extra_info={
-                "chapter": item["chapter"],
-                "article": item["article"],
-                "title": item["title"],
-            },
-        )
-        documents.append(document)
-
-    return documents
-
-
-def initialize_index(index_name):
-    file_path = f"./vectorStores/{index_name}"
-    if os.path.exists(file_path):
-        # rebuild storage context
-        storage_context = StorageContext.from_defaults(persist_dir=file_path)
-
-        # local load index access
-        index = load_index_from_storage(storage_context)
-
-        # huggingface repo load access
-        # with fs.open(file_path, "r") as file:
-        #     index = pickle.loads(file.readlines())
-        return index
-    else:
-        documents = prepare_data(r"./assets/regItems.json")
-        index = GPTVectorStoreIndex.from_documents(
-            documents, service_context=service_context
-        )
-        # local write access
-        index.storage_context.persist(file_path)
-
-        # huggingface repo write access
-        # with fs.open(file_path, "w") as file:
-        #     file.write(pickle.dumps(index))
-        return index

models/langOpen.py

@@ -0,0 +1,46 @@
+import os
+
+import openai
+from dotenv import load_dotenv
+from langchain.chains import LLMChain
+from langchain.chat_models import ChatOpenAI
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate
+from langchain.vectorstores import FAISS
+
+load_dotenv()
+
+embeddings = OpenAIEmbeddings()
+
+prompt_template = """Answer the question using the given context to the best of your ability. 
+If you don't know, answer I don't know.
+Context: {context}
+Topic: {topic}"""
+
+PROMPT = PromptTemplate(template=prompt_template, input_variables=["context", "topic"])
+
+
+class LangOpen:
+    def __init__(self, model_name: str) -> None:
+        self.index = self.initialize_index("langOpen")
+        self.llm = ChatOpenAI(temperature=0.3, model=model_name)
+        self.chain = LLMChain(llm=self.llm, prompt=PROMPT)
+
+    def initialize_index(self, index_name):
+        path = f"./vectorStores/{index_name}"
+        if os.path.exists(path=path):
+            return FAISS.load_local(folder_path=path, embeddings=embeddings)
+        else:
+            faiss = FAISS.from_texts(
+                "./assets/updated_calregs.txt", embedding=embeddings
+            )
+            faiss.save_local(path)
+            return faiss
+
+    def get_response(self, query_str):
+        print("query_str: ", query_str)
+        print("model_name: ", self.llm.model_name)
+        docs = self.index.similarity_search(query_str, k=4)
+        inputs = [{"context": doc.page_content, "topic": query_str} for doc in docs]
+        result = self.chain.apply(inputs)[0]["text"]
+        return result

models/llamaCustom.py

@@ -0,0 +1,123 @@
+import os
+import pickle
+from json import dumps, loads
+from typing import Any, List, Mapping, Optional
+
+import numpy as np
+import openai
+import pandas as pd
+from dotenv import load_dotenv
+from huggingface_hub import HfFileSystem
+from langchain.llms.base import LLM
+from llama_index import (
+    Document,
+    GPTVectorStoreIndex,
+    LLMPredictor,
+    PromptHelper,
+    ServiceContext,
+    SimpleDirectoryReader,
+    StorageContext,
+    load_index_from_storage,
+)
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+# from utils.customLLM import CustomLLM
+
+load_dotenv()
+# openai.api_key = os.getenv("OPENAI_API_KEY")
+fs = HfFileSystem()
+
+# define prompt helper
+# set maximum input size
+CONTEXT_WINDOW = 2048
+# set number of output tokens
+NUM_OUTPUT = 525
+# set maximum chunk overlap
+CHUNK_OVERLAP_RATION = 0.2
+
+prompt_helper = PromptHelper(
+    context_window=CONTEXT_WINDOW,
+    num_output=NUM_OUTPUT,
+    chunk_overlap_ratio=CHUNK_OVERLAP_RATION,
+)
+
+llm_model_name = "bigscience/bloom-560m"
+tokenizer = AutoTokenizer.from_pretrained(llm_model_name)
+model = AutoModelForCausalLM.from_pretrained(llm_model_name, config="T5Config")
+
+model_pipeline = pipeline(
+    model=model,
+    tokenizer=tokenizer,
+    task="text-generation",
+    # device=0, # GPU device number
+    # max_length=512,
+    do_sample=True,
+    top_p=0.95,
+    top_k=50,
+    temperature=0.7,
+)
+
+
+class CustomLLM(LLM):
+    pipeline = model_pipeline
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        prompt_length = len(prompt)
+        response = self.pipeline(prompt, max_new_tokens=525)[0]["generated_text"]
+
+        # only return newly generated tokens
+        return response[prompt_length:]
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        return {"name_of_model": self.model_name}
+
+    @property
+    def _llm_type(self) -> str:
+        return "custom"
+
+
+class LlamaCustom:
+    # define llm
+    llm_predictor = LLMPredictor(llm=CustomLLM())
+    service_context = ServiceContext.from_defaults(
+        llm_predictor=llm_predictor, prompt_helper=prompt_helper
+    )
+
+    def __init__(self, name: str) -> None:
+        self.vector_index = self.initialize_index(index_name=name)
+
+    def initialize_index(self, index_name):
+        file_path = f"./vectorStores/{index_name}"
+        if os.path.exists(path=file_path):
+            # rebuild storage context
+            storage_context = StorageContext.from_defaults(persist_dir=file_path)
+
+            # local load index access
+            index = load_index_from_storage(storage_context)
+
+            # huggingface repo load access
+            # with fs.open(file_path, "r") as file:
+            #     index = pickle.loads(file.readlines())
+            return index
+        else:
+            # documents = prepare_data(r"./assets/regItems.json")
+            documents = SimpleDirectoryReader(input_dir="./assets/pdf").load_data()
+
+            index = GPTVectorStoreIndex.from_documents(
+                documents, service_context=self.service_context
+            )
+
+            # local write access
+            index.storage_context.persist(file_path)
+
+            # huggingface repo write access
+            # with fs.open(file_path, "w") as file:
+            #     file.write(pickle.dumps(index))
+            return index
+
+    def get_response(self, query_str):
+        print("query_str: ", query_str)
+        query_engine = self.vector_index.as_query_engine()
+        response = query_engine.query(query_str)
+        return str(response)

pages/langchain_demo.py

@@ -0,0 +1,26 @@
+import os
+
+import openai
+import streamlit as st
+
+from models.langOpen import LangOpen
+from utils.chatbox import chatbox
+
+st.set_page_config(page_title="Langchain", page_icon="")
+
+st.subheader("Langchain with OpenAI Demo")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "openai_api_key" not in st.session_state:
+    st.info("Enter your openai key to access the chatbot.")
+else:
+    option = st.selectbox(
+        label="Select your model:", options=("gpt-3.5-turbo", "gpt-4"), index=0
+    )
+
+    with st.spinner(f"Initializing {option} ..."):
+        langOpen = LangOpen(model_name=option)
+
+    chatbox("lang_open", langOpen)

pages/llama_custom_demo.py

@@ -0,0 +1,23 @@
+import os
+import time
+
+import openai
+import streamlit as st
+
+from models.llamaCustom import LlamaCustom
+from utils.chatbox import *
+
+st.set_page_config(page_title="Llama", page_icon="🦙")
+
+st.subheader("Llama Index with Custom LLM Demo")
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "openai_api_key" not in st.session_state:
+    st.info("Enter your openai key to access the chatbot.")
+else:
+    with st.spinner("Initializing vector index"):
+        model = LlamaCustom(name="llamaCustom")
+
+    chatbox("llama_custom", model)

requirements.txt

@@ -9,4 +9,5 @@ faiss-cpu
 python-dotenv
 streamlit>=1.24.0
 huggingface_hub
-xformers
+xformers
+pypdf

utils/chatbox.py

@@ -0,0 +1,94 @@
+import time
+
+import streamlit as st
+
+def display_chat_history(model_name: str):
+    for message in st.session_state[model_name]:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+def chat_input(model_name: str):
+    if prompt := st.chat_input("Say something"):
+        # Display user message in chat message container
+        st.chat_message("user").markdown(prompt)
+
+        # Add user message to chat history
+        st.session_state[model_name].append({"role": "user", "content": prompt})
+
+        return prompt
+
+def display_bot_msg(model_name: str, bot_response: str):
+    # Display assistant response in chat message container
+    with st.chat_message("assistant"):
+        message_placeholder = st.empty()
+        full_response = ""
+
+        # simulate the chatbot "thinking" before responding
+        # (or stream its response)
+        for chunk in bot_response.split():
+            full_response += chunk + " "
+            time.sleep(0.05)
+
+            # add a blinking cursor to simulate typing
+            message_placeholder.markdown(full_response + "▌")
+
+        message_placeholder.markdown(full_response)
+        # st.markdown(response)
+
+    # Add assistant response to chat history
+    st.session_state[model_name].append(
+        {"model_name": model_name, "role": "assistant", "content": full_response}
+    )
+
+# @st.cache_data
+def chatbox(model_name: str, model: None):
+    # Display chat messages from history on app rerun
+    for message in st.session_state.messages:
+        if (message["model_name"] == model_name):
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+    if prompt := st.chat_input("Say something"):
+        # Display user message in chat message container
+        st.chat_message("user").markdown(prompt)
+
+        # Add user message to chat history
+        st.session_state.messages.append({"model_name": model_name, "role": "user", "content": prompt})
+
+        with st.spinner("Processing your query..."):
+            bot_response = model.get_response(prompt)
+
+        print("bot: ", bot_response)
+
+        # Display assistant response in chat message container
+        with st.chat_message("assistant"):
+            message_placeholder = st.empty()
+            full_response = ""
+
+            # simulate the chatbot "thinking" before responding
+            # (or stream its response)
+            for chunk in bot_response.split():
+                full_response += chunk + " "
+                time.sleep(0.05)
+
+                # add a blinking cursor to simulate typing
+                message_placeholder.markdown(full_response + "▌")
+
+            message_placeholder.markdown(full_response)
+            # st.markdown(response)
+
+        # Add assistant response to chat history
+        st.session_state.messages.append(
+            {"model_name": model_name, "role": "assistant", "content": full_response}
+        )
+
+        # Scroll to the bottom of the chat container
+        # st.markdown(
+        #     """
+        #     <script>
+        #     const chatContainer = document.getElementsByClassName("css-1n76uvr")[0];
+        #     chatContainer.scrollTop = chatContainer.scrollHeight;
+        #     </script>
+        #     """,
+        #     unsafe_allow_html=True,
+        # )

utils/customLLM.py

@@ -1,38 +0,0 @@
-from typing import Any, List, Mapping, Optional
-
-from langchain.llms.base import LLM
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-
-model_name = "bigscience/bloom-560m" 
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(model_name, config='T5Config')
-
-pl = pipeline(
-    model=model,
-    tokenizer=tokenizer,
-    task="text-generation",
-    # device=0, # GPU device number
-    # max_length=512,
-    do_sample=True,
-    top_p=0.95,
-    top_k=50,
-    temperature=0.7
-)
-
-class CustomLLM(LLM):
-    pipeline = pl
-
-    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
-        prompt_length = len(prompt)
-        response = self.pipeline(prompt, max_new_tokens=525)[0]["generated_text"]
-
-        # only return newly generated tokens
-        return response[prompt_length:]
-
-    @property
-    def _identifying_params(self) -> Mapping[str, Any]:
-        return {"name_of_model": self.model_name}
-
-    @property
-    def _llm_type(self) -> str:
-        return "custom"

utils/util.py

@@ -13,15 +13,3 @@ def validate(token: str):
 
     response = requests.post(api_endpoint, json=data, headers=headers)
     return response
-
-
-def create_index(model):
-    index = model.initialize_index("bloomLlama")
-    return index
-
-
-def get_response(vector_index, query_str):
-    print("query_str: ", query_str)
-    query_engine = vector_index.as_query_engine()
-    response = query_engine.query(query_str)
-    return str(response)