complete app.py

app.py

@@ -1,107 +1,139 @@
-import os
-from typing import Optional, Tuple
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.agents import AgentExecutor, Tool, load_tools
+from langchain.chains import RetrievalQA, RetrievalQAWithSourcesChain, LLMChain, LLMMathChain
+from langchain.chat_models import ChatOpenAI
+from langchain.document_loaders import DirectoryLoader
+from langchain.memory import ConversationBufferMemory
+from langchain.utilities import WikipediaAPIWrapper
+from langchain.agents import initialize_agent, AgentType
+from langchain.document_loaders import WebBaseLoader
 
 import gradio as gr
-from langchain.chains import ConversationChain
-from langchain.llms import OpenAI
-from threading import Lock
-
-
-def load_chain():
-    """Logic for loading the chain you want to use should go here."""
-    llm = OpenAI(temperature=0)
-    chain = ConversationChain(llm=llm)
-    return chain
-
-
-def set_openai_api_key(api_key: str):
-    """Set the api key and return chain.
-
-    If no api_key, then None is returned.
-    """
-    if api_key:
-        os.environ["OPENAI_API_KEY"] = api_key
-        chain = load_chain()
-        os.environ["OPENAI_API_KEY"] = ""
-        return chain
-
-class ChatWrapper:
-
-    def __init__(self):
-        self.lock = Lock()
-    def __call__(
-        self, api_key: str, inp: str, history: Optional[Tuple[str, str]], chain: Optional[ConversationChain]
-    ):
-        """Execute the chat functionality."""
-        self.lock.acquire()
-        try:
-            history = history or []
-            # If chain is None, that is because no API key was provided.
-            if chain is None:
-                history.append((inp, "Please paste your OpenAI key to use"))
-                return history, history
-            # Set OpenAI key
-            import openai
-            openai.api_key = api_key
-            # Run chain and append input.
-            output = chain.run(input=inp)
-            history.append((inp, output))
-        except Exception as e:
-            raise e
-        finally:
-            self.lock.release()
-        return history, history
-
-chat = ChatWrapper()
-
-block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
-
-with block:
-    with gr.Row():
-        gr.Markdown("<h3><center>LangChain Demo</center></h3>")
-
-        openai_api_key_textbox = gr.Textbox(
-            placeholder="Paste your OpenAI API key (sk-...)",
-            show_label=False,
-            lines=1,
-            type="password",
-        )
 
-    chatbot = gr.Chatbot()
+# Add presets for Gradio theme
+from app_modules.presets import * 
 
-    with gr.Row():
-        message = gr.Textbox(
-            label="What's your question?",
-            placeholder="What's the answer to life, the universe, and everything?",
-            lines=1,
+import os
+os.environ["OPENAI_API_KEY"] = "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"
+
+# Flag to load chroma store
+flag_chroma = True
+
+# Define the LLM chat model
+#model = 'gpt-3.5-turbo'
+model = 'gpt-4'
+temperature = 0
+llm = ChatOpenAI(temperature=temperature, model=model)
+
+# Check flag to load vectorstore
+if flag_chroma:
+    # Load an existing database
+    persist_dir = "./chroma"
+    embeddings = OpenAIEmbeddings()
+    vectorstore = Chroma(persist_directory=persist_dir, embedding_function=embeddings)
+    vectorstore.persist()
+else:
+    # Document and sources loader
+    pdf_loader = DirectoryLoader('./Reports/', glob="**/*.pdf")
+    txt_loader = DirectoryLoader('./Reports/', glob="**/*.txt")
+    word_loader = DirectoryLoader('./Reports/', glob="**/*.docx")
+    web_based_loader = WebBaseLoader(["https://www.unwomen.org/en/what-we-do/ending-violence-against-women/faqs/types-of-violence", "https://2021.gho.unocha.org/global-trends/gender-and-gender-based-violence-humanitarian-action/"])
+
+    loaders = [pdf_loader, txt_loader, word_loader, web_based_loader]
+    docs = []
+    for loader in loaders:
+        docs.extend(loader.load())
+
+    # Text splitter
+    ## If chunks are bigger than 1000, it recursively splits them until fitting them within size
+    text_splitter = RecursiveCharacterTextSplitter(
+        separators=["\n\n", "\n", ".", "!", "?", ",", " ", ""],
+        chunk_size = 1000,
+        chunk_overlap  = 50
+    )
+    documents = text_splitter.split_documents(docs)
+
+    # Embed documents in Vectorstore
+    persist_dir = "chroma"
+    embeddings = OpenAIEmbeddings()
+    vectorstore = Chroma.from_documents(documents, embeddings, persist_directory=persist_dir)
+    vectorstore.persist()
+
+# Create Retrieval Chain with sources
+## It returns a dictionary with at least the 'answer' and the 'sources'
+qa = RetrievalQAWithSourcesChain.from_chain_type(
+            llm=llm,
+            chain_type="stuff",
+            retriever=vectorstore.as_retriever(),
+            return_source_documents=True
         )
-        submit = gr.Button(value="Send", variant="secondary").style(full_width=False)
-
-    gr.Examples(
-        examples=[
-            "Hi! How's it going?",
-            "What should I do tonight?",
-            "Whats 2 + 2?",
-        ],
-        inputs=message,
+
+# Define tools
+wikipedia = WikipediaAPIWrapper()
+
+tools = [
+    Tool(
+        name="GBV Q&A Bot System",
+        #func=qa,
+        func=lambda question: qa({"question": question}, return_only_outputs=True),
+        description="Useful for when you need to answer questions about the aspects asked. Input may be a partial or fully formed question.",
+        #return_direct=True, # use the agent as a router and directly return the result
+    ),
+    Tool(
+        name='Wikipedia',
+        func=wikipedia.run,
+        description='You must only use this tool if you cannot find answers with the other tools. Useful for when you need to look for answers in the Wikipedia.'
     )
+]
 
-    gr.HTML("Demo application of a LangChain chain.")
+# Create Buffer Memory
+memory = ConversationBufferMemory(memory_key="chat_history", input_key='input', output_key="output", return_messages=True)
 
-    gr.HTML(
-        "<center>Powered by <a href='https://github.com/hwchase17/langchain'>LangChain 🦜️🔗</a></center>"
-    )
+# Initialize Re-Act agent and create Agent Executor Chain
+react = initialize_agent(tools, llm, agent=AgentType.CHAT_CONVERSATIONAL_REACT_DESCRIPTION, verbose=True, max_iterations=3, early_stopping_method='generate',  memory=memory)
 
-    state = gr.State()
-    agent_state = gr.State()
+agent_chain = AgentExecutor.from_agent_and_tools(
+                agent=react.agent, tools=tools, verbose=True, memory=memory, return_intermediate_steps=True, return_source_documents=True, handle_parsing_errors=True
+            )
 
-    submit.click(chat, inputs=[openai_api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
-    message.submit(chat, inputs=[openai_api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+# Add custom CSS
+with open("assets/custom.css", "r", encoding="utf-8") as f:
+    customCSS = f.read()
 
-    openai_api_key_textbox.change(
-        set_openai_api_key,
-        inputs=[openai_api_key_textbox],
-        outputs=[agent_state],
+with gr.Blocks(css=customCSS, theme=small_and_beautiful_theme) as demo:
+    
+    gr.Markdown(
+        """
+        # 🦜🔗 Ask GBV Q&A Bot!
+        Start typing below to see the output.
+        """
+    )
+    
+    # Start chatbot with welcome from bot
+    chatbot = gr.Chatbot([(None,'How can I help you?')]).style(height=650)
+    msg = gr.Textbox()
+    clear = gr.ClearButton([msg, chatbot])
+
+    def user(user_message, history):
+        return gr.update(value="", interactive=False), history + [[user_message, None]]
+
+    def bot(history):
+        user_message = history[-1][0] # get if from most recent history element
+        #bot_message  = conversation.run(user_message)
+        response = agent_chain(user_message)
+        bot_message = response['output']
+        history[-1][1] = ""
+        for character in bot_message:
+            history[-1][1] += character
+            #time.sleep(0.05)
+            yield history
+
+    response = msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
+        bot, chatbot, chatbot
     )
+    response.then(lambda: gr.update(interactive=True), None, [msg], queue=False)
 
-block.launch(debug=True)
+demo.queue()
+demo.launch()