init

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.streamlit/

app.py

@@ -0,0 +1,7 @@
+import streamlit as st
+from streamlit.external.langchain import StreamlitCallbackHandler
+
+st.set_page_config(page_title="ChatBot", page_icon="🤭")
+
+st.title("CHOOSE FROM THE SIDEBAR")
+st.sidebar.success("Select a demo above 🐮")

chat.py

@@ -0,0 +1,121 @@
+import logging
+import os
+import tempfile
+from langchain.chains import ConversationalRetrievalChain, ConversationChain
+from langchain_openai import AzureOpenAIEmbeddings, AzureChatOpenAI
+from langchain.retrievers import ContextualCompressionRetriever
+from langchain.retrievers.document_compressors import EmbeddingsFilter
+from langchain.schema import BaseRetriever, Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import DocArrayInMemorySearch
+from langchain.agents import initialize_agent, AgentType
+from langchain_community.agent_toolkits.load_tools import load_tools
+from utils import MEMORY, load_document
+import streamlit as st
+
+logging.basicConfig(encoding="utf-8", level=logging.INFO)
+LOGGER = logging.getLogger()
+
+def config_retriever(docs: list[Document], use_compression=False, chunk_size=1500):
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap = 200)
+    splits = text_splitter.split_documents(docs)
+
+    embeddings = AzureOpenAIEmbeddings(
+        api_key=st.secrets['key'],
+        azure_deployment=st.secrets['embedding_name'], 
+        openai_api_version=st.secrets['embedding_version'],
+        azure_endpoint=st.secrets['endpoint'],
+    )
+
+    vectorDB = DocArrayInMemorySearch.from_documents(splits, embeddings)
+    retriever = vectorDB.as_retriever(
+        search_type='mmr',
+        search_kwargs={
+            "k": 5,
+            "fetch_k": 7,
+            "include_metadata": True
+        }
+    )
+    if not use_compression:
+        return retriever
+    else:
+        embeddings_filter = EmbeddingsFilter(
+            embeddings=embeddings, similarity_threshold=0.2
+        )
+        return ContextualCompressionRetriever(
+            base_compressor=embeddings_filter,
+            base_retriever=retriever
+        )
+
+def config_baseretrieval_chain(retriever: BaseRetriever, temperature=0.1):
+    LLM = AzureChatOpenAI(
+        api_key=st.secrets['key'],
+        openai_api_version=st.secrets['chat_version'],
+        azure_deployment=st.secrets['chat_name'],
+        azure_endpoint=st.secrets['endpoint'],
+        temperature=temperature,
+    )
+
+    MEMORY.output_key = 'answer'
+    params = dict(
+        llm=LLM,
+        retriever=retriever,
+        memory=MEMORY,
+        verbose=True
+    )
+    return ConversationalRetrievalChain.from_llm(**params)
+    
+def ddg_search_agent(temperature=0.1):
+    LLM = AzureChatOpenAI(
+        api_key=st.secrets['key'],
+        openai_api_version=st.secrets['chat_version'],
+        azure_deployment=st.secrets['chat_name'],
+        azure_endpoint=st.secrets['endpoint'],
+        temperature=temperature,
+    )
+    
+    tools = load_tools(
+        tool_names=['ddg-search'],
+        llm=LLM,
+        model="gpt-4o-mini"
+    )
+    return initialize_agent(
+        tools=tools, llm=LLM, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True, handle_parsing_errors=True
+    )
+    
+def config_retrieval_chain(
+        upload_files,
+        use_compression=False,
+        use_chunksize=1500,
+        use_temperature=0.1,
+        use_zeroshoot=False
+):
+    docs = []
+    temp_dir = tempfile.TemporaryDirectory()
+    for file in upload_files:
+        temp_filepath = os.path.join(temp_dir.name, file.name)
+        with open(temp_filepath, "wb") as f:
+            f.write(file.getvalue())
+        docs.extend(load_document(temp_filepath))
+    
+    retriever = config_retriever(docs=docs, use_compression=use_compression, chunk_size=use_chunksize)
+    chain = config_baseretrieval_chain(retriever=retriever, temperature=use_temperature)
+    if use_zeroshoot:
+        return ddg_search_agent(temperature=use_temperature)
+    else:
+        return chain
+    
+def config_noretrieval_chain(use_temperature=0.1,use_zeroshoot=False):
+    LLM = AzureChatOpenAI(
+        api_key=st.secrets['key'],
+        openai_api_version=st.secrets['chat_version'],
+        azure_deployment=st.secrets['chat_name'],
+        azure_endpoint=st.secrets['endpoint'],
+        temperature=use_temperature,
+    )
+    if use_zeroshoot:
+        return ddg_search_agent(temperature=use_temperature)
+    else:
+        return ConversationChain(llm=LLM)
+
+    

pages/Chatbot.py

@@ -0,0 +1,45 @@
+import streamlit as st
+import logging
+from utils import MEMORY, DocumentLoader, check_password
+from chat import config_noretrieval_chain
+from streamlit.external.langchain import StreamlitCallbackHandler
+
+logging.basicConfig(encoding="utf-8", level=logging.INFO)
+LOGGER = logging.getLogger()
+
+def main_chat_ui():
+    use_temperature = st.sidebar.slider(
+        'Temperature 🦄',
+        0.0, 1.0, (0.1))
+    use_ddg_search = st.checkbox("Search on DuckDuckGO🦆", value=False)
+    
+    CONV_CHAIN = config_noretrieval_chain(
+        use_temperature=use_temperature,
+        use_zeroshoot=use_ddg_search
+    )
+    if st.sidebar.button("Clear History🦭"):
+        MEMORY.chat_memory.clear()
+    if len(MEMORY.chat_memory.messages) == 0:
+        st.chat_message("assistant").markdown("Ask me something🤖")
+    
+    avatars = {"human": "user", "ai": "assistant"}
+    if user_query := st.chat_input(placeholder="Say something🐻"):
+        st.chat_message("user").write(user_query)
+        container = st.empty()
+        stream_handler = StreamlitCallbackHandler(container)
+        with st.chat_message("assistant"):
+            if use_ddg_search:
+                response = CONV_CHAIN.invoke(
+                    {"input": user_query}, {"callbacks": [stream_handler]}
+                )
+                st.write(response["output"])
+            else:
+                response = CONV_CHAIN.run(user_query)
+                if response:
+                    container.markdown(response)
+
+
+if not check_password():
+    st.stop()
+st.title("👻START CHAT👻")
+main_chat_ui()

pages/Chatbot_with_uploaded_docs.py

@@ -0,0 +1,69 @@
+import streamlit as st
+import logging
+from utils import MEMORY, DocumentLoader, check_password
+from chat import config_retrieval_chain
+from streamlit.external.langchain import StreamlitCallbackHandler
+
+logging.basicConfig(encoding="utf-8", level=logging.INFO)
+LOGGER = logging.getLogger()
+
+def main_RAG_ui():
+    use_chunk = st.sidebar.slider(
+        'Chunk Size',
+        500, 2000, (1000)
+    )
+    use_temperature = st.sidebar.slider(
+        'Temperature 🦄',
+        0.0, 1.0, (0.1))
+    use_compression = st.checkbox("Compression🛠️(on uploaded document)", value=False)
+    use_ddg_search = st.checkbox("Search on DuckDuckGO🦆(does not use document)", value=False)
+
+    
+    CONV_CHAIN = config_retrieval_chain(
+        uploaded_files,
+        use_compression=use_compression,
+        use_chunksize=use_chunk,
+        use_temperature=use_temperature,
+        use_zeroshoot=use_ddg_search
+    )
+    if st.sidebar.button("Clear History🦭"):
+        MEMORY.chat_memory.clear()
+    if len(MEMORY.chat_memory.messages) == 0:
+        st.chat_message("assistant").markdown("Ask me something🤖")
+    avatars = {"human": "user", "ai": "assistant"}
+
+    if user_query := st.chat_input(placeholder="Say something🐻"):
+        st.chat_message("user").write(user_query)
+        container = st.empty()
+        stream_handler = StreamlitCallbackHandler(container)
+        with st.chat_message("assistant"):
+            if use_ddg_search:
+                response = CONV_CHAIN.invoke(
+                    {"input": user_query}, {"callbacks": [stream_handler]}
+                )
+                st.write(response["output"])
+            else:
+                params = {
+                    "question": user_query,
+                    "chat_history": MEMORY.chat_memory.messages,
+                }
+                response = CONV_CHAIN.run(params, callbacks=[stream_handler])
+                if response:
+                    container.markdown(response)
+
+
+if not check_password():
+    st.stop()
+st.title("👻START CHAT👻")
+
+uploaded_files = st.sidebar.file_uploader(
+    label="Upload a file🐣",
+    type=list(DocumentLoader.supported_extensions.keys()),
+    accept_multiple_files=True
+)
+
+if not uploaded_files:
+    st.info("Upload a file to start🐣")
+    st.stop()
+
+main_RAG_ui()

requirements.txt

@@ -0,0 +1,10 @@
+docarray==0.40.0
+duckduckgo_search==6.2.1
+langchain==0.2.11
+langchain-community==0.2.10
+langchain-core==0.2.23
+langchain-openai==0.1.17
+langchain-text-splitters==0.2.2
+langsmith==0.1.93
+pypdf==4.3.1
+streamlit==1.36.0

utils.py

@@ -0,0 +1,63 @@
+import logging
+import pathlib
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import TextLoader
+from langchain.memory import ConversationBufferMemory
+from langchain.schema import Document
+import hmac
+import streamlit as st
+
+def init_memory(key):
+    """
+    Initialize the memory for contextual conversation.
+
+    We are caching this, so it won't be deleted every time, we restart the server.
+    """
+    return ConversationBufferMemory(
+        memory_key=key,
+        return_messages=True,
+        output_key='answer'
+    )
+MEMORY = init_memory('chat_history')
+
+class DocumentLoaderException(Exception):
+    pass
+
+class DocumentLoader(object):
+    supported_extensions = {
+        ".pdf": PyPDFLoader,
+        ".txt": TextLoader
+    }
+
+def load_document(temp_filepath: str) -> list[Document]:
+    ext = pathlib.Path(temp_filepath).suffix
+    loader = DocumentLoader.supported_extensions.get(ext)
+    if not loader:
+        raise DocumentLoaderException(
+            f"Invalid file extension: <{ext}>"
+        )
+
+    loaded = loader(temp_filepath)
+    docs = loaded.load()
+    logging.info(docs)
+    return docs
+
+
+def check_password():
+    st.header("")
+    def password_entered():
+        if hmac.compare_digest(st.session_state["password"], st.secrets["adminpassword"]):
+            st.session_state["password_correct"] = True
+            del st.session_state["password"]  # Don't store the password.
+        else:
+            st.session_state["password_correct"] = False
+
+    if st.session_state.get("password_correct", False):
+        return True
+    
+    st.text_input(
+        "Enter Password 🚀", type="password", on_change=password_entered, key="password"
+    )
+    if "password_correct" in st.session_state:
+        st.error("Password incorrect 😕")
+    return False