hooha

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Nima Mahmoudi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -9,4 +9,4 @@ app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agent_helper.py

@@ -0,0 +1,67 @@
+# from langchain.callbacks import StreamlitCallbackHandler
+from langchain.callbacks.streamlit.streamlit_callback_handler import StreamlitCallbackHandler
+from tenacity import retry, wait_exponential, stop_after_attempt
+
+def bind_logger(toolClass):
+    class newToolClass(toolClass):
+        def __init__(self, tool_name: str, st_cb: StreamlitCallbackHandler, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.st_cb = st_cb
+            self.tool_name = tool_name
+
+        def run(self, *args, **kwargs):
+            print(f"Running {toolClass.__name__} {[*args]}, {kwargs}")
+
+            if self.st_cb._current_thought is None:
+                self.st_cb.on_llm_start({}, [])
+
+            args_str = ' '.join(args) + ' ' + ' '.join([f'{k}=`{v}`' for k, v in kwargs.items()])
+            self.st_cb.on_tool_start({'name': self.tool_name}, args_str)
+
+            try:
+                ret_val = retry(
+                    wait=wait_exponential(min=2, max=20),
+                    stop=stop_after_attempt(5),
+                )(super().run)(*args, **kwargs)
+                self.st_cb.on_tool_end(ret_val)
+                return ret_val
+            except Exception as e:
+                original_exception = e.last_attempt.result()
+                print(f"Exception {original_exception} in {toolClass.__name__} {[*args]}, {kwargs}")
+                raise original_exception
+            
+        
+    return newToolClass
+        
+from functools import wraps
+
+def retry_and_streamlit_callback(st_cb: StreamlitCallbackHandler, tool_name: str):
+    if st_cb is None:
+        return lambda x: x
+
+    def decorator(tool_func):
+        @wraps(tool_func)
+        def decorated_func(*args, **kwargs):
+            print(f"Running {tool_name} {args}, {kwargs}")
+
+            if st_cb._current_thought is None:
+                st_cb.on_llm_start({}, [])
+
+            args_str = ' '.join(args) + ' ' + ' '.join([f'{k}=`{v}`' for k, v in kwargs.items()])
+            st_cb.on_tool_start({'name': tool_name}, args_str)
+
+            @retry(wait=wait_exponential(min=2, max=20), stop=stop_after_attempt(5))
+            def retry_wrapper():
+                return tool_func(*args, **kwargs)
+
+            try:
+                ret_val = retry_wrapper()
+                st_cb.on_tool_end(ret_val)
+                return ret_val
+            except Exception as e:
+                print(f"Exception {e} in {tool_name} {args}, {kwargs}")
+                raise e
+
+        return decorated_func
+
+    return decorator

app-agent.py

@@ -0,0 +1,59 @@
+import streamlit as st
+
+from langchain.agents import initialize_agent, AgentType
+from langchain.callbacks import StreamlitCallbackHandler
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from llm_helper import get_agent_chain, get_lc_oai_tools
+
+with st.sidebar:
+    openai_api_key = st.secrets["OPENAI_API_KEY"]
+    "[Get an OpenAI API key](https://platform.openai.com/account/api-keys)"
+    "[View the source code](https://github.com/streamlit/llm-examples/blob/main/pages/2_Chat_with_search.py)"
+    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/streamlit/llm-examples?quickstart=1)"
+
+st.title("🔎 LangChain - Chat with search")
+
+"""
+In this example, we're using `StreamlitCallbackHandler` to display the thoughts and actions of an agent in an interactive Streamlit app.
+Try more LangChain 🤝 Streamlit Agent examples at [github.com/langchain-ai/streamlit-agent](https://github.com/langchain-ai/streamlit-agent).
+"""
+
+if "messages" not in st.session_state:
+    st.session_state["messages"] = [
+        {"role": "assistant", "content": "Hi, I'm a chatbot who can search the web. How can I help you?"}
+    ]
+
+for msg in st.session_state.messages:
+    st.chat_message(msg["role"]).write(msg["content"])
+
+if prompt := st.chat_input(placeholder="Who won the Women's U.S. Open in 2018?"):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    st.chat_message("user").write(prompt)
+
+    if not openai_api_key:
+        st.info("Please add your OpenAI API key to continue.")
+        st.stop()
+
+    llm = ChatOpenAI(model_name="gpt-3.5-turbo-1106", openai_api_key=openai_api_key, streaming=True)
+    lc_tools, _ = get_lc_oai_tools()
+    search_agent = initialize_agent(lc_tools, llm, agent=AgentType.OPENAI_FUNCTIONS, handle_parsing_errors=True, verbose=True)
+
+    agent_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", "You are a helpful assistant, use the search tool to answer the user's question and cite only the page number when you use information coming (like [p1]) from the source document. Always use the content from the source document to answer the user's question. If you need to compare multiple subjects, search them one by one."),
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+    search_agent.agent.prompt = agent_prompt
+    with st.chat_message("assistant"):
+        st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
+        response = search_agent.run(prompt, callbacks=[st_cb])
+        # search_agent = get_agent_chain(callbacks=[st_cb])
+        # response = search_agent.invoke({"input": prompt})
+        # response = response["output"]
+        
+        st.session_state.messages.append({"role": "assistant", "content": response})
+        st.write(response)

app-agent2.py

@@ -0,0 +1,59 @@
+import streamlit as st
+
+from langchain.agents import initialize_agent, AgentType
+from langchain.callbacks import StreamlitCallbackHandler
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+
+from langchain.agents.format_scratchpad import format_to_openai_function_messages
+from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+
+from llm_helper import get_agent_chain, get_lc_oai_tools, convert_message
+from langchain.agents import AgentExecutor
+
+with st.sidebar:
+    openai_api_key = st.secrets["OPENAI_API_KEY"]
+    "[Get an OpenAI API key](https://platform.openai.com/account/api-keys)"
+    "[View the source code](https://github.com/streamlit/llm-examples/blob/main/pages/2_Chat_with_search.py)"
+    "[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/streamlit/llm-examples?quickstart=1)"
+
+st.title("🔎 LangChain - Chat with search")
+
+"""
+In this example, we're using `StreamlitCallbackHandler` to display the thoughts and actions of an agent in an interactive Streamlit app.
+Try more LangChain 🤝 Streamlit Agent examples at [github.com/langchain-ai/streamlit-agent](https://github.com/langchain-ai/streamlit-agent).
+"""
+
+if "messages" not in st.session_state:
+    st.session_state["messages"] = [
+        {"role": "assistant", "content": "Hi, I'm a chatbot who can search the web. How can I help you?"}
+    ]
+
+for msg in st.session_state.messages:
+    st.chat_message(msg["role"]).write(msg["content"])
+
+if prompt := st.chat_input(placeholder="Who won the Women's U.S. Open in 2018?"):
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    st.chat_message("user").write(prompt)
+
+    if not openai_api_key:
+        st.info("Please add your OpenAI API key to continue.")
+        st.stop()
+
+    if "messages" in st.session_state:
+        chat_history = [convert_message(m) for m in st.session_state.messages[:-1]]
+    else:
+        chat_history = []
+
+    with st.chat_message("assistant"):
+        st_cb = StreamlitCallbackHandler(st.container(), expand_new_thoughts=False)
+        agent = get_agent_chain(st_cb=st_cb)
+
+        response = agent.invoke({
+            "input": prompt,
+            "chat_history": chat_history,
+        })
+        response = response["output"]
+        
+        st.session_state.messages.append({"role": "assistant", "content": response})
+        st.write(response)

app.py

@@ -0,0 +1,168 @@
+import streamlit as st
+import os
+import embed_pdf
+import shutil
+
+def clear_directory(directory):
+    for filename in os.listdir(directory):
+        file_path = os.path.join(directory, filename)
+        try:
+            if os.path.isfile(file_path) or os.path.islink(file_path):
+                os.unlink(file_path)
+            elif os.path.isdir(file_path):
+                shutil.rmtree(file_path)
+        except Exception as e:
+            print(f'Failed to delete {file_path}. Reason: {e}')
+
+def clear_pdf_files(directory):
+    for filename in os.listdir(directory):
+        file_path = os.path.join(directory, filename)
+        try:
+            if os.path.isfile(file_path) and file_path.endswith('.pdf'):
+                os.remove(file_path)
+        except Exception as e:
+            print(f'Failed to delete {file_path}. Reason: {e}')
+
+# clear_pdf_files("pdf")
+# clear_directory("index")
+
+
+# create sidebar and ask for openai api key if not set in secrets
+secrets_file_path = os.path.join(".streamlit", "secrets.toml")
+# if os.path.exists(secrets_file_path):
+#     try:
+#         if "OPENAI_API_KEY" in st.secrets:
+#             os.environ["OPENAI_API_KEY"] = st.secrets["OPENAI_API_KEY"]
+#         else:
+#             print("OpenAI API Key not found in environment variables")
+#     except FileNotFoundError:
+#         print('Secrets file not found')
+# else:
+#     print('Secrets file not found')
+
+# if not os.getenv('OPENAI_API_KEY', '').startswith("sk-"):
+#     os.environ["OPENAI_API_KEY"] = st.sidebar.text_input(
+#         "OpenAI API Key", type="password"
+#     )
+# else:
+#     if st.sidebar.button("Embed Documents"):
+#         st.sidebar.info("Embedding documents...")
+#         try:
+#             embed_pdf.embed_all_pdf_docs()
+#             st.sidebar.info("Done!")
+#         except Exception as e:
+#             st.sidebar.error(e)
+#             st.sidebar.error("Failed to embed documents.")
+
+os.environ["OPENAI_API_KEY"] = st.sidebar.text_input(
+    "OpenAI API Key", type="password"
+)
+
+uploaded_file = st.sidebar.file_uploader("Upload Document", type=['pdf', 'docx'], disabled=False)
+
+if uploaded_file is None:
+    file_uploaded_bool = False
+else:
+    file_uploaded_bool = True
+
+if st.sidebar.button("Embed Documents", disabled=not file_uploaded_bool):
+    st.sidebar.info("Embedding documents...")
+    try:
+        embed_pdf.embed_all_inputed_pdf_docs(uploaded_file)
+        # embed_pdf.embed_all_pdf_docs()
+        st.sidebar.info("Done!")
+    except Exception as e:
+        st.sidebar.error(e)
+        st.sidebar.error("Failed to embed documents.")
+
+# create the app
+st.title("Chat with your PDF")
+
+# chosen_file = st.radio(
+#     "Choose a file to search", embed_pdf.get_all_index_files(), index=0
+# )
+
+# check if openai api key is set
+if not os.getenv('OPENAI_API_KEY', '').startswith("sk-"):
+    st.warning("Please enter your OpenAI API key!", icon="⚠")
+    st.stop()
+
+# load the agent
+from llm_helper import convert_message, get_rag_chain, get_rag_fusion_chain
+
+rag_method_map = {
+    'Basic RAG': get_rag_chain,
+    'RAG Fusion': get_rag_fusion_chain
+}
+chosen_rag_method = st.radio(
+    "Choose a RAG method", rag_method_map.keys(), index=0
+)
+get_rag_chain_func = rag_method_map[chosen_rag_method]
+## get the chain WITHOUT the retrieval callback (not used)
+# custom_chain = get_rag_chain_func(chosen_file)
+
+# create the message history state
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+# render older messages
+for message in st.session_state.messages:
+    with st.chat_message(message["role"]):
+        st.markdown(message["content"])
+
+# render the chat input
+prompt = st.chat_input("Enter your message...")
+if prompt:
+    st.session_state.messages.append({"role": "user", "content": prompt})
+
+    # render the user's new message
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    # render the assistant's response
+    with st.chat_message("assistant"):
+        retrival_container = st.container()
+        message_placeholder = st.empty()
+
+        # retrieval_status = retrival_container.status("**Context Retrieval**")
+        queried_questions = []
+        rendered_questions = set()
+        def update_retrieval_status():
+            for q in queried_questions:
+                if q in rendered_questions:
+                    continue
+                rendered_questions.add(q)
+                # retrieval_status.markdown(f"\n\n`- {q}`")
+                retrival_container.markdown(f"\n\n`- {q}`")
+        def retrieval_cb(qs):
+            for q in qs:
+                if q not in queried_questions:
+                    queried_questions.append(q)
+            return qs
+        
+        # get the chain with the retrieval callback
+        custom_chain = get_rag_chain_func(uploaded_file.name, retrieval_cb=retrieval_cb)
+        
+        if "messages" in st.session_state:
+            chat_history = [convert_message(m) for m in st.session_state.messages[:-1]]
+        else:
+            chat_history = []
+
+        full_response = ""
+        for response in custom_chain.stream(
+            {"input": prompt, "chat_history": chat_history}
+        ):
+            if "output" in response:
+                full_response += response["output"]
+            else:
+                full_response += response.content
+
+            message_placeholder.markdown(full_response + "▌")
+            update_retrieval_status()
+
+        # retrival_container.update(state="complete")
+        # retrieval_status.update(state="complete")
+        message_placeholder.markdown(full_response)
+
+    # add the full response to the message history
+    st.session_state.messages.append({"role": "assistant", "content": full_response})

embed_pdf.py

@@ -0,0 +1,95 @@
+from langchain.document_loaders import PagedPDFSplitter
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import FAISS
+
+import os
+
+
+def embed_document(file_name, file_folder="pdf", embedding_folder="index"):
+    file_path = f"{file_folder}/{file_name}"
+    loader = PagedPDFSplitter(file_path)
+    source_pages = loader.load_and_split()
+
+    embedding_func = OpenAIEmbeddings()
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500,
+        chunk_overlap=100,
+        length_function=len,
+        is_separator_regex=False,
+        separators=["\n\n", "\n", " ", ""],
+    )
+    source_chunks = text_splitter.split_documents(source_pages)
+    search_index = FAISS.from_documents(source_chunks, embedding_func)
+    search_index.save_local(
+        folder_path=embedding_folder, index_name=file_name + ".index"
+    )
+
+def embed_all_inputed_pdf_docs(uploaded_document):
+    # Define the directory path
+    pdf_directory = "pdf"
+    pdf_file_path = os.path.join(pdf_directory, uploaded_document.name)
+
+    with open(pdf_file_path, 'wb') as file:
+        file.write(uploaded_document.getbuffer())
+
+    # Check if the directory exists
+    if os.path.exists(pdf_directory):
+        # List all PDF files in the directory
+        pdf_files = [
+            file for file in os.listdir(pdf_directory) if file.endswith(".pdf")
+        ]
+
+        if pdf_files:
+            for pdf_file in pdf_files:
+                print(f"Embedding {pdf_file}...")
+                embed_document(file_name=pdf_file, file_folder=pdf_directory)
+                print("Done!")
+        else:
+            raise Exception("No PDF files found in the directory.")
+    else:
+        raise Exception(f"Directory '{pdf_directory}' does not exist.")
+
+
+def embed_all_pdf_docs():
+    # Define the directory path
+    pdf_directory = "pdf"
+
+    # Check if the directory exists
+    if os.path.exists(pdf_directory):
+        # List all PDF files in the directory
+        pdf_files = [
+            file for file in os.listdir(pdf_directory) if file.endswith(".pdf")
+        ]
+
+        if pdf_files:
+            for pdf_file in pdf_files:
+                print(f"Embedding {pdf_file}...")
+                embed_document(file_name=pdf_file, file_folder=pdf_directory)
+                print("Done!")
+        else:
+            raise Exception("No PDF files found in the directory.")
+    else:
+        raise Exception(f"Directory '{pdf_directory}' does not exist.")
+
+
+def get_all_index_files():
+    # Define the directory path
+    index_directory = "index"
+
+    # Check if the directory exists
+    if os.path.exists(index_directory):
+        # List all index files in the directory
+        postfix = ".index.faiss"
+        index_files = [
+            file.replace(postfix, "")
+            for file in os.listdir(index_directory)
+            if file.endswith(postfix)
+        ]
+
+        if index_files:
+            return index_files
+        else:
+            raise Exception("No index files found in the directory.")
+    else:
+        raise Exception(f"Directory '{index_directory}' does not exist.")

index/.gitignore

@@ -0,0 +1,2 @@
+*.faiss
+*.pkl

llm_helper.py

@@ -0,0 +1,289 @@
+from typing import Optional
+
+# langchain imports
+from langchain.chat_models import ChatOpenAI
+from langchain.schema.runnable import RunnableMap
+from langchain.prompts.prompt import PromptTemplate
+from langchain.prompts import ChatPromptTemplate
+from langchain.schema.runnable import RunnablePassthrough
+from langchain.schema.output_parser import StrOutputParser
+from operator import itemgetter
+from langchain.schema.messages import HumanMessage, SystemMessage, AIMessage
+from langchain.callbacks.streamlit.streamlit_callback_handler import StreamlitCallbackHandler
+
+
+def format_docs(docs):
+    res = ""
+    # res = str(docs)
+    for doc in docs:
+        escaped_page_content = doc.page_content.replace("\n", "\\n")
+        res += "<doc>\n"
+        res += f"  <content>{escaped_page_content}</content>\n"
+        for m in doc.metadata:
+            res += f"  <{m}>{doc.metadata[m]}</{m}>\n"
+        res += "</doc>\n"
+    return res
+
+
+def get_search_index(file_name="Mahmoudi_Nima_202202_PhD.pdf", index_folder="index"):
+    # load embeddings
+    from langchain.vectorstores import FAISS
+    from langchain.embeddings.openai import OpenAIEmbeddings
+
+    search_index = FAISS.load_local(
+        folder_path=index_folder,
+        index_name=file_name + ".index",
+        embeddings=OpenAIEmbeddings(),
+    )
+    return search_index
+
+
+def convert_message(m):
+    if m["role"] == "user":
+        return HumanMessage(content=m["content"])
+    elif m["role"] == "assistant":
+        return AIMessage(content=m["content"])
+    elif m["role"] == "system":
+        return SystemMessage(content=m["content"])
+    else:
+        raise ValueError(f"Unknown role {m['role']}")
+
+
+_condense_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.
+
+Chat History:
+{chat_history}
+Follow Up Input: {input}
+Standalone question:"""
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_condense_template)
+
+_rag_template = """Answer the question based only on the following context, citing the page number(s) of the document(s) you used to answer the question:
+{context}
+
+Question: {question}
+"""
+ANSWER_PROMPT = ChatPromptTemplate.from_template(_rag_template)
+
+
+def _format_chat_history(chat_history):
+    def format_single_chat_message(m):
+        if type(m) is HumanMessage:
+            return "Human: " + m.content
+        elif type(m) is AIMessage:
+            return "Assistant: " + m.content
+        elif type(m) is SystemMessage:
+            return "System: " + m.content
+        else:
+            raise ValueError(f"Unknown role {m['role']}")
+
+    return "\n".join([format_single_chat_message(m) for m in chat_history])
+
+def get_standalone_question_from_chat_history_chain():
+    _inputs = RunnableMap(
+        standalone_question=RunnablePassthrough.assign(
+            chat_history=lambda x: _format_chat_history(x["chat_history"])
+        )
+        | CONDENSE_QUESTION_PROMPT
+        | ChatOpenAI(temperature=0)
+        | StrOutputParser(),
+    )
+    return _inputs
+
+def get_rag_chain(file_name, index_folder="index", retrieval_cb=None):
+    vectorstore = get_search_index(file_name, index_folder)
+    retriever = vectorstore.as_retriever()
+
+    if retrieval_cb is None:
+        retrieval_cb = lambda x: x
+
+    def context_update_fn(q):
+        retrieval_cb([q])
+        return q
+
+    _inputs = RunnableMap(
+        standalone_question=RunnablePassthrough.assign(
+            chat_history=lambda x: _format_chat_history(x["chat_history"])
+        )
+        | CONDENSE_QUESTION_PROMPT
+        | ChatOpenAI(temperature=0)
+        | StrOutputParser(),
+    )
+    _context = {
+        "context": itemgetter("standalone_question") | RunnablePassthrough(context_update_fn) | retriever | format_docs,
+        "question": lambda x: x["standalone_question"],
+    }
+    conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI()
+    return conversational_qa_chain
+
+
+# RAG fusion chain
+# source1: https://youtu.be/GchC5WxeXGc?si=6i7J0rPZI7SNwFYZ
+# source2: https://towardsdatascience.com/forget-rag-the-future-is-rag-fusion-1147298d8ad1
+def reciprocal_rank_fusion(results: list[list], k=60):
+    from langchain.load import dumps, loads
+    fused_scores = {}
+    for docs in results:
+        # Assumes the docs are returned in sorted order of relevance
+        for rank, doc in enumerate(docs):
+            doc_str = dumps(doc)
+            if doc_str not in fused_scores:
+                fused_scores[doc_str] = 0
+            fused_scores[doc_str] += 1 / (rank + k)
+
+    reranked_results = [
+        (loads(doc), score)
+        for doc, score in sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
+    ]
+    return reranked_results
+
+
+def get_search_query_generation_chain():
+    from langchain.prompts import SystemMessagePromptTemplate, HumanMessagePromptTemplate
+    prompt = ChatPromptTemplate(
+        input_variables=['original_query'],
+        messages=[
+            SystemMessagePromptTemplate(
+                prompt=PromptTemplate(
+                    input_variables=[],
+                    template='You are a helpful assistant that generates multiple search queries based on a single input query.'
+                )
+            ),
+            HumanMessagePromptTemplate(
+                prompt=PromptTemplate(
+                    input_variables=['original_query'],
+                    template='Generate multiple search queries related to: {original_query} \n OUTPUT (4 queries):'
+                )
+            )
+        ]
+    )
+
+    generate_queries = (
+        prompt |
+        ChatOpenAI(temperature=0) |
+        StrOutputParser() |
+        (lambda x: x.split("\n"))
+    )
+
+    return generate_queries
+
+def get_rag_fusion_chain(file_name, index_folder="index", retrieval_cb=None):
+    vectorstore = get_search_index(file_name, index_folder)
+    retriever = vectorstore.as_retriever()
+    query_generation_chain = get_search_query_generation_chain()
+    _inputs = RunnableMap(
+        standalone_question=RunnablePassthrough.assign(
+            chat_history=lambda x: _format_chat_history(x["chat_history"])
+        )
+        | CONDENSE_QUESTION_PROMPT
+        | ChatOpenAI(temperature=0)
+        | StrOutputParser(),
+    )
+
+    if retrieval_cb is None:
+        retrieval_cb = lambda x: x
+
+    _context = {
+        "context":
+            RunnablePassthrough.assign(
+                original_query=lambda x: x["standalone_question"]
+            )
+            | query_generation_chain
+            | retrieval_cb
+            | retriever.map()
+            | reciprocal_rank_fusion
+            | (lambda x: [item[0] for item in x])
+            | format_docs,
+        "question": lambda x: x["standalone_question"],
+    }
+    conversational_qa_chain = _inputs | _context | ANSWER_PROMPT | ChatOpenAI()
+    return conversational_qa_chain
+
+
+####################
+# Adding agent chain with OpenAI function calling
+
+def get_search_tool_from_index(search_index, st_cb: Optional[StreamlitCallbackHandler] = None, ):
+    from langchain.agents import tool
+    from agent_helper import retry_and_streamlit_callback
+
+    @tool
+    @retry_and_streamlit_callback(st_cb=st_cb, tool_name="Content Seach Tool")
+    def search(query: str) -> str:
+        """Search the contents of the source document for the queries."""
+
+        docs = search_index.similarity_search(query, k=5)
+        return format_docs(docs)
+    
+    return search
+
+def get_lc_oai_tools(file_name:str = "Mahmoudi_Nima_202202_PhD.pdf", index_folder: str = "index", st_cb: Optional[StreamlitCallbackHandler] = None, ):
+    from langchain.tools.render import format_tool_to_openai_tool
+    search_index = get_search_index(file_name, index_folder)
+    lc_tools = [get_search_tool_from_index(search_index=search_index, st_cb=st_cb)]
+    oai_tools = [format_tool_to_openai_tool(t) for t in lc_tools]
+    return lc_tools, oai_tools
+
+def get_agent_chain(file_name="Mahmoudi_Nima_202202_PhD.pdf", index_folder="index", callbacks=None, st_cb: Optional[StreamlitCallbackHandler] = None, ):
+    if callbacks is None:
+        callbacks = []
+
+    from langchain.agents import initialize_agent, AgentType
+    from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+    from langchain.agents.format_scratchpad.openai_tools import (
+        format_to_openai_tool_messages,
+    )
+    from langchain.agents import AgentExecutor
+    from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser
+
+    lc_tools, oai_tools = get_lc_oai_tools(file_name, index_folder, st_cb)
+    
+
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", "You are a helpful assistant, use the search tool to answer the user's question and cite only the page number when you use information coming (like [p1]) from the source document.\nchat history: {chat_history}"),
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+    llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-1106")
+
+    agent = (
+        {
+            "input": lambda x: x["input"],
+            "agent_scratchpad": lambda x: format_to_openai_tool_messages(
+                x["intermediate_steps"]
+            ),
+            "chat_history": lambda x: _format_chat_history(x["chat_history"]),
+        }
+        | prompt
+        | llm.bind(tools=oai_tools)
+        | OpenAIToolsAgentOutputParser()
+    )
+
+    agent_executor = AgentExecutor(agent=agent, tools=lc_tools, verbose=True, callbacks=callbacks)
+    return agent_executor
+
+
+if __name__ == "__main__":
+    question_generation_chain = get_search_query_generation_chain()
+    print('='*50)
+    print('RAG Chain')
+    chain = get_rag_chain()
+    print(chain.invoke({'input': 'serverless computing', 'chat_history': []}))
+
+    print('='*50)
+    print('Question Generation Chain')
+    print(question_generation_chain.invoke({'original_query': 'serverless computing'}))
+
+    print('-'*50)
+    print('RAG Fusion Chain')
+    chain = get_rag_fusion_chain()
+    print(chain.invoke({'input': 'serverless computing', 'chat_history': []}))
+
+    agent_executor = get_agent_chain()
+    print(
+        agent_executor.invoke({
+            "input": "based on the source document, compare FaaS with BaaS??",
+            "chat_history": [],
+        })
+    )

pdf/.gitignore

@@ -0,0 +1 @@
+*.pdf

pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "llm-streamlit-demo-basic"
+version = "0.1.0"
+description = ""
+authors = ["Nima Mahmoudi <[email protected]>"]
+
+[tool.poetry.dependencies]
+python = ">=3.10.0,<3.11"
+langchain = "^0.0.321"
+openai = "^0.28.1"
+streamlit = "^1.27.2"
+faiss-cpu = "^1.7.4"
+tiktoken = "^0.5.1"
+langchainhub = "^0.1.13"
+pypdf = "^3.17.0"
+
+[tool.pyright]
+# https://github.com/microsoft/pyright/blob/main/docs/configuration.md
+useLibraryCodeForTypes = true
+exclude = [".cache"]
+
+[tool.ruff]
+# https://beta.ruff.rs/docs/configuration/
+select = ['E', 'W', 'F', 'I', 'B', 'C4', 'ARG', 'SIM']
+ignore = ['W291', 'W292', 'W293']
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

requirements.txt

@@ -0,0 +1,7 @@
+langchain
+openai
+streamlit==1.25.0
+faiss-cpu
+tiktoken
+langchainhub
+pypdf