new files

.history/app_20230720012201.py

@@ -0,0 +1,105 @@
+import os
+from threading import Lock
+import gradio as gr
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import OpenAI, HuggingFaceHub
+
+
+def load_chain(chain_type: str, api_key: str) -> Optional[ConversationChain]:
+    if chain_type == 'openai':
+        os.environ["OPENAI_API_KEY"] = api_key
+        llm = OpenAI(temperature=0)
+    elif chain_type == 'falcon':
+        os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+        llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    else:
+        print(f'Invalid chain_type: {chain_type}')
+        return None
+
+    chain = ConversationChain(llm=llm)
+
+    # Unset the API keys
+    os.environ.pop('OPENAI_API_KEY', None)
+    os.environ.pop('HUGGINGFACEHUB_API_TOKEN', None)
+
+    return chain
+
+
+class ChatWrapper:
+    def __init__(self, chain=None):
+        self.chain = chain
+        self.history = []
+        self.lock = Lock()
+
+    def __call__(self, inp: str):
+        with self.lock:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            try:
+                output = self.chain.run(input=inp)
+                self.history.append((inp, output))
+            except Exception as e:
+                self.history.append((inp, f"An error occurred: {e}"))
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chain = load_chain(chain_type=selection, api_key=api_key)
+    chat_wrapper = ChatWrapper(chain=chain)
+
+
+def chat(message: str):
+    global chat_wrapper
+    return chat_wrapper(message)
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your API key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="Your Message",
+            placeholder="Enter your message here",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720115617.py

@@ -0,0 +1,105 @@
+import os
+from threading import Lock
+import gradio as gr
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import OpenAI, HuggingFaceHub
+
+
+def load_chain(chain_type: str, api_key: str) -> Optional[ConversationChain]:
+    if chain_type == 'openai':
+        os.environ["OPENAI_API_KEY"] = api_key
+        llm = OpenAI(temperature=0)
+    elif chain_type == 'falcon':
+        os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+        llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    else:
+        print(f'Invalid chain_type: {chain_type}')
+        return None
+
+    chain = ConversationChain(llm=llm)
+
+    # Unset the API keys
+    os.environ.pop('OPENAI_API_KEY', None)
+    os.environ.pop('HUGGINGFACEHUB_API_TOKEN', None)
+
+    return chain
+
+
+class ChatWrapper:
+    def __init__(self, chain=None):
+        self.chain = chain
+        self.history = []
+        self.lock = Lock()
+
+    def __call__(self, inp: str):
+        with self.lock:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            try:
+                output = self.chain.run(input=inp)
+                self.history.append((inp, output))
+            except Exception as e:
+                self.history.append((inp, f"An error occurred: {e}"))
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chain = load_chain(chain_type=selection, api_key=api_key)
+    chat_wrapper = ChatWrapper(chain=chain)
+
+
+def chat(message: str):
+    global chat_wrapper
+    return chat_wrapper(message)
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your API key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="Your Message",
+            placeholder="Enter your message here",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720115808.py

@@ -0,0 +1,165 @@
+# import gradio as gr
+# from src.main import ChatWrapper
+
+# # Initialize an empty ChatWrapper initially
+# chat_wrapper = ChatWrapper(chain_type="openai", api_key="")
+
+# def update_chain(api_key_textbox, selection):
+#     global chat_wrapper  # We use the global chat_wrapper here
+#     chat_wrapper = ChatWrapper(selection, api_key_textbox)  # Re-initialize chat_wrapper
+
+# block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+# with block:
+#     with gr.Row():
+#         gr.Markdown("<h2><center>ConversationalChain App (+Model Selection)</center></h3>")
+#         selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai", label_width="150px")
+#         api_key_textbox = gr.Textbox(label="API Key", placeholder="Paste your API key", lines=1, type="password")
+
+#     chatbot = gr.Chatbot()
+
+#     with gr.Row():
+#         message = gr.Textbox(label="What's your question?", placeholder="What's the answer to life, the universe, and everything?", lines=1)
+#         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)
+#     gr.HTML("Demo application of a LangChain chain.")
+
+#     state = gr.State()
+#     agent_state = gr.State()
+
+#     # Update the chat_wrapper when the API key or chain type is changed
+#     api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+#     selection.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+#     # Modify the chat_wrapper to accept state and agent state, and to return a response and updated states
+#     def chat(api_key, selection, message, state, agent_state):
+#         print(f"chat called with api_key: {api_key}, selection: {selection}, message: {message}, state: {state}, agent_state: {agent_state}")
+#         chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+#         history = chat_wrapper(message)
+#         return history, state, agent_state
+
+#     submit.click(chat, inputs=[api_key_textbox, selection, message, state, agent_state], outputs=[chatbot, state, agent_state])
+#     message.submit(chat, inputs=[api_key_textbox, selection, message, state, agent_state], outputs=[chatbot, state, agent_state])
+
+# block.launch(debug=True)
+
+
+
+
+import os
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import HuggingFaceHub
+from langchain.llms import OpenAI
+from threading import Lock
+import gradio as gr
+
+
+def load_chain_openai(api_key: str):
+    os.environ["OPENAI_API_KEY"] = api_key
+    llm = OpenAI(temperature=0)
+    chain = ConversationChain(llm=llm)
+    os.environ["OPENAI_API_KEY"] = ""
+    return chain
+
+
+def load_chain_falcon(api_key: str):
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+    llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    chain = ConversationChain(llm=llm)
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = ""
+    return chain
+
+
+class ChatWrapper:
+    def __init__(self, chain_type: str, api_key: str = ''):
+        self.api_key = api_key
+        self.chain_type = chain_type
+        self.history = []
+        self.lock = Lock()
+
+        if self.api_key:
+            if chain_type == 'openai':
+                self.chain = load_chain_openai(self.api_key)
+            elif chain_type == 'falcon':
+                self.chain = load_chain_falcon(self.api_key)
+            else:
+                raise ValueError(f'Invalid chain_type: {chain_type}')
+        else:
+            self.chain = None
+
+    def __call__(self, inp: str):
+        self.lock.acquire()
+        try:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            output = self.chain.run(input=inp)
+            self.history.append((inp, output))
+        except Exception as e:
+            self.history.append((inp, f"An error occurred: {e}"))
+        finally:
+            self.lock.release()
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720115842.py

@@ -0,0 +1,274 @@
+# import gradio as gr
+# from src.main import ChatWrapper
+
+# # Initialize an empty ChatWrapper initially
+# chat_wrapper = ChatWrapper(chain_type="openai", api_key="")
+
+# def update_chain(api_key_textbox, selection):
+#     global chat_wrapper  # We use the global chat_wrapper here
+#     chat_wrapper = ChatWrapper(selection, api_key_textbox)  # Re-initialize chat_wrapper
+
+# block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+# with block:
+#     with gr.Row():
+#         gr.Markdown("<h2><center>ConversationalChain App (+Model Selection)</center></h3>")
+#         selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai", label_width="150px")
+#         api_key_textbox = gr.Textbox(label="API Key", placeholder="Paste your API key", lines=1, type="password")
+
+#     chatbot = gr.Chatbot()
+
+#     with gr.Row():
+#         message = gr.Textbox(label="What's your question?", placeholder="What's the answer to life, the universe, and everything?", lines=1)
+#         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)
+#     gr.HTML("Demo application of a LangChain chain.")
+
+#     state = gr.State()
+#     agent_state = gr.State()
+
+#     # Update the chat_wrapper when the API key or chain type is changed
+#     api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+#     selection.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+#     # Modify the chat_wrapper to accept state and agent state, and to return a response and updated states
+#     def chat(api_key, selection, message, state, agent_state):
+#         print(f"chat called with api_key: {api_key}, selection: {selection}, message: {message}, state: {state}, agent_state: {agent_state}")
+#         chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+#         history = chat_wrapper(message)
+#         return history, state, agent_state
+
+#     submit.click(chat, inputs=[api_key_textbox, selection, message, state, agent_state], outputs=[chatbot, state, agent_state])
+#     message.submit(chat, inputs=[api_key_textbox, selection, message, state, agent_state], outputs=[chatbot, state, agent_state])
+
+# block.launch(debug=True)
+
+
+
+
+import os
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import HuggingFaceHub
+from langchain.llms import OpenAI
+from threading import Lock
+import gradio as gr
+
+
+def load_chain_openai(api_key: str):
+    os.environ["OPENAI_API_KEY"] = api_key
+    llm = OpenAI(temperature=0)
+    chain = ConversationChain(llm=llm)
+    os.environ["OPENAI_API_KEY"] = ""
+    return chain
+
+
+def load_chain_falcon(api_key: str):
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+    llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    chain = ConversationChain(llm=llm)
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = ""
+    return chain
+
+
+class ChatWrapper:
+    def __init__(self, chain_type: str, api_key: str = ''):
+        self.api_key = api_key
+        self.chain_type = chain_type
+        self.history = []
+        self.lock = Lock()
+
+        if self.api_key:
+            if chain_type == 'openai':
+                self.chain = load_chain_openai(self.api_key)
+            elif chain_type == 'falcon':
+                self.chain = load_chain_falcon(self.api_key)
+            else:
+                raise ValueError(f'Invalid chain_type: {chain_type}')
+        else:
+            self.chain = None
+
+    def __call__(self, inp: str):
+        self.lock.acquire()
+        try:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            output = self.chain.run(input=inp)
+            self.history.append((inp, output))
+        except Exception as e:
+            self.history.append((inp, f"An error occurred: {e}"))
+        finally:
+            self.lock.release()
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)
+
+
+
+# ######## old code
+# import os
+# from threading import Lock
+# import gradio as gr
+# from typing import Any, Optional, Tuple
+# from langchain.chains import ConversationChain
+# from langchain.llms import OpenAI, HuggingFaceHub
+
+
+# def load_chain(chain_type: str, api_key: str) -> Optional[ConversationChain]:
+#     if chain_type == 'openai':
+#         os.environ["OPENAI_API_KEY"] = api_key
+#         llm = OpenAI(temperature=0)
+#     elif chain_type == 'falcon':
+#         os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+#         llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+#     else:
+#         print(f'Invalid chain_type: {chain_type}')
+#         return None
+
+#     chain = ConversationChain(llm=llm)
+
+#     # Unset the API keys
+#     os.environ.pop('OPENAI_API_KEY', None)
+#     os.environ.pop('HUGGINGFACEHUB_API_TOKEN', None)
+
+#     return chain
+
+
+# class ChatWrapper:
+#     def __init__(self, chain=None):
+#         self.chain = chain
+#         self.history = []
+#         self.lock = Lock()
+
+#     def __call__(self, inp: str):
+#         with self.lock:
+#             if self.chain is None:
+#                 self.history.append((inp, "Please add your API key to proceed."))
+#                 return self.history
+
+#             try:
+#                 output = self.chain.run(input=inp)
+#                 self.history.append((inp, output))
+#             except Exception as e:
+#                 self.history.append((inp, f"An error occurred: {e}"))
+
+#         return self.history, self.history
+
+
+# chat_wrapper = ChatWrapper()
+
+# def update_chain(api_key: str, selection: str):
+#     global chat_wrapper
+#     chain = load_chain(chain_type=selection, api_key=api_key)
+#     chat_wrapper = ChatWrapper(chain=chain)
+
+
+# def chat(message: str):
+#     global chat_wrapper
+#     return chat_wrapper(message)
+
+# block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+# with block:
+#     with gr.Row():
+#         gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+#         selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+#         api_key_textbox = gr.Textbox(
+#             label="API Key",
+#             placeholder="Paste your API key",
+#             show_label=True,
+#             lines=1,
+#             type="password",
+#         )
+
+#     chatbot = gr.Chatbot()
+
+#     with gr.Row():
+#         message = gr.Textbox(
+#             label="Your Message",
+#             placeholder="Enter your message here",
+#             lines=1,
+#         )
+#         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,
+#     )
+
+#     gr.HTML("Demo application of a LangChain chain.")
+
+#     state = gr.State()
+#     agent_state = gr.State()
+
+#     submit.click(chat, inputs=[message], outputs=[chatbot, state])
+#     message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+#     api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+# block.launch(debug=True)

.history/app_20230720120047.py

@@ -0,0 +1,116 @@
+import os
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import HuggingFaceHub
+from langchain.llms import OpenAI
+from threading import Lock
+import gradio as gr
+
+
+def load_chain_openai(api_key: str):
+    os.environ["OPENAI_API_KEY"] = api_key
+    llm = OpenAI(temperature=0)
+    chain = ConversationChain(llm=llm)
+    os.environ["OPENAI_API_KEY"] = ""
+    return chain
+
+
+def load_chain_falcon(api_key: str):
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+    llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    chain = ConversationChain(llm=llm)
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = ""
+    return chain
+
+
+class ChatWrapper:
+    def __init__(self, chain_type: str, api_key: str = ''):
+        self.api_key = api_key
+        self.chain_type = chain_type
+        self.history = []
+        self.lock = Lock()
+
+        if self.api_key:
+            if chain_type == 'openai':
+                self.chain = load_chain_openai(self.api_key)
+            elif chain_type == 'falcon':
+                self.chain = load_chain_falcon(self.api_key)
+            else:
+                raise ValueError(f'Invalid chain_type: {chain_type}')
+        else:
+            self.chain = None
+
+    def __call__(self, inp: str):
+        self.lock.acquire()
+        try:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            output = self.chain.run(input=inp)
+            self.history.append((inp, output))
+        except Exception as e:
+            self.history.append((inp, f"An error occurred: {e}"))
+        finally:
+            self.lock.release()
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720120625.py

@@ -0,0 +1,115 @@
+import os
+from typing import Any, Optional, Tuple
+from langchain.chains import ConversationChain
+from langchain.llms import HuggingFaceHub
+from langchain.llms import OpenAI
+from threading import Lock
+import gradio as gr
+
+
+def load_chain_openai(api_key: str):
+    os.environ["OPENAI_API_KEY"] = api_key
+    llm = OpenAI(temperature=0)
+    chain = ConversationChain(llm=llm)
+    os.environ["OPENAI_API_KEY"] = ""
+    return chain
+
+
+def load_chain_falcon(api_key: str):
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = api_key
+    llm = HuggingFaceHub(repo_id="tiiuae/falcon-7b-instruct", model_kwargs={"temperature": 0.9})
+    chain = ConversationChain(llm=llm)
+    os.environ["HUGGINGFACEHUB_API_TOKEN"] = ""
+    return chain
+
+class ChatWrapper:
+    def __init__(self, chain_type: str, api_key: str = ''):
+        self.api_key = api_key
+        self.chain_type = chain_type
+        self.history = []
+        self.lock = Lock()
+
+        if self.api_key:
+            if chain_type == 'openai':
+                self.chain = load_chain_openai(self.api_key)
+            elif chain_type == 'falcon':
+                self.chain = load_chain_falcon(self.api_key)
+            else:
+                raise ValueError(f'Invalid chain_type: {chain_type}')
+        else:
+            self.chain = None
+
+    def __call__(self, inp: str):
+        self.lock.acquire()
+        try:
+            if self.chain is None:
+                self.history.append((inp, "Please add your API key to proceed."))
+                return self.history
+
+            output = self.chain.run(input=inp)
+            self.history.append((inp, output))
+        except Exception as e:
+            self.history.append((inp, f"An error occurred: {e}"))
+        finally:
+            self.lock.release()
+
+        return self.history, self.history
+
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720120933.py

@@ -0,0 +1,60 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720130430.py

@@ -0,0 +1,53 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain=selection, api_key=api_key)
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720130724.py

@@ -0,0 +1,53 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat
+    chat = ChatWrapper(chain=selection, api_key=api_key)
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720131115.py

@@ -0,0 +1,54 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat
+    chat = ChatWrapper(api_key=api_key, chain=selection)
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720131814.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat
+    chat = ChatWrapper(api_key=api_key, chain=selection)
+    return chat
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720132136.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, selection: str):
+    global chat
+    chat = ChatWrapper(api_key=api_key, chain=selection)
+    return chat
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+    selection.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720132503.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, message: str, state: str, selection: str):
+    global chat
+    chat = ChatWrapper(api_key=api_key, input=message, history=state str, chain=selection)
+    return chat
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+    selection.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720132518.py

@@ -0,0 +1,55 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat = ChatWrapper()
+
+def update_chain(api_key: str, message: str, state: str, selection: str):
+    global chat
+    chat = ChatWrapper(api_key=api_key, input=message, history=state str, chain=selection)
+    return chat
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+    message.submit(chat, inputs=[api_key_textbox, message, state, agent_state], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+    selection.change(update_chain, inputs=[api_key_textbox, message, state, agent_state], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720133035.py

@@ -0,0 +1,60 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720133118.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+chat_wrapper = ChatWrapper('openai')  # default chain_type is 'openai'
+
+def update_chain(api_key: str, selection: str):
+    global chat_wrapper
+    chat_wrapper = ChatWrapper(chain_type=selection, api_key=api_key)
+    return chat_wrapper # This is agent state
+
+def chat(message):
+    global chat_wrapper
+    chat_wrapper(message)  # Get a response to the current message
+    history = chat_wrapper.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_chain, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720133714.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720134604.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h3><center>Hello-World LangChain App</center></h3>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("Demo application of a LangChain chain.")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720135305.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720135438.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720135623.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h1><center>ConversationalChain App 🤖</center></h1>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720135741.py

@@ -0,0 +1,66 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_label(api_key: str, selection: str):
+    label_text = "Put your HuggingFace API Key" if selection == "falcon" else "Put your OpenAI API Key"
+    return {"markdown": label_text}   #update the markdown
+   
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h1><center>ConversationalChain App 🤖</center></h1>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            update_api_key_label,
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720140423.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    label_text = "Put your HuggingFace API Key" if selection == "falcon" else "Put your OpenAI API Key"
+    return agent, {"markdown": label_text} # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+agent_api_label = gr.Markdown()
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h1><center>ConversationalChain App 🤖</center></h1>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            agent_api_label,
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state, agent_api_label])
+
+block.launch(debug=True)

.history/app_20230720140424.py

@@ -0,0 +1,64 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    label_text = "Put your HuggingFace API Key" if selection == "falcon" else "Put your OpenAI API Key"
+    return agent, {"markdown": label_text} # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+agent_api_label = gr.Markdown()
+
+with block:
+    with gr.Row():
+        gr.Markdown("<h1><center>ConversationalChain App 🤖</center></h1>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            agent_api_label,
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state, agent_api_label])
+
+block.launch(debug=True)

.history/app_20230720141203.py

@@ -0,0 +1,66 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    if selection == "falcon":
+        api_key_textbox.placeholder = "Paste your Huggingface API key"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720141228.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720141747.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    # api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720141944.py

@@ -0,0 +1,62 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720142413.py

@@ -0,0 +1,70 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+        
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")
+        # API_KEY_TEXTBOX if selection if Falcon then "HuggingFace API Key" else "OpenAI API Key
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder="Paste your OpenAI API key (sk-...)",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720142550.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+    return api_key_textbox.placeholder
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            # Updating api_key_textbox placeholder based on selection
+            placeholder=update_api_key_palceholder
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720142627.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+    return api_key_textbox.placeholder
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            # Updating api_key_textbox placeholder based on selection
+            placeholder= update_api_key_palceholder(),
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720142635.py

@@ -0,0 +1,71 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+    return api_key_textbox.placeholder
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            # Updating api_key_textbox placeholder based on selection
+            placeholder= update_api_key_palceholder,
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720142718.py

@@ -0,0 +1,69 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            # Updating api_key_textbox placeholder based on selection
+            placeholder= update_api_key_palceholder,
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720142924.py

@@ -0,0 +1,69 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+    api_key_textbox.refresh()
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste your API key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143034.py

@@ -0,0 +1,68 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste your API key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143041.py

@@ -0,0 +1,68 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= update_api_key_palceholder,
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143109.py

@@ -0,0 +1,68 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= update_api_key_palceholder(selection.value),
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143123.py

@@ -0,0 +1,68 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= update_api_key_palceholder(selection.value),
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    # selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143149.py

@@ -0,0 +1,68 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= update_api_key_palceholder(selection.value),
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143312.py

@@ -0,0 +1,67 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection: str):
+    if selection == 'falcon':
+        "Paste your HuggingFace API key hf_...)"
+    else:
+        "Paste your OpenAI API key (sk-...)"
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= update_api_key_palceholder(selection.value),
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720143545.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key (hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+
+    # Manually update the placeholder text in the HTML
+    api_key_textbox.render()
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143613.py

@@ -0,0 +1,72 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+def update_api_key_palceholder(selection):
+    if selection == 'falcon':
+        api_key_textbox.placeholder = "Paste your HuggingFace API key (hf_...)"
+    else:
+        api_key_textbox.placeholder = "Paste your OpenAI API key (sk-...)"
+
+    # Manually update the placeholder text in the HTML
+    return api_key_textbox.render()
+
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_api_key_palceholder, inputs=[selection])
+
+block.launch(debug=True)

.history/app_20230720143706.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    
+block.launch(debug=True)

.history/app_20230720143740.py

@@ -0,0 +1,63 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+        gr.HTML("For Falcon use HuggingFace API Token, for OpenAI use OpenAI API Key")
+
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720143814.py

@@ -0,0 +1,63 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2>")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+    gr.HTML("For Falcon use HuggingFace API Token, for OpenAI use OpenAI API Key")
+
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720143901.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2> <br> For Falcon use HuggingFace API Token, for OpenAI use OpenAI API Key")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720144009.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2> <br> For <a href="https://huggingface.co/tiiuae/falcon-7b-instruct">Falcon</a> use HuggingFace API Token, for OpenAI use OpenAI API Key")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720144049.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2> <br> For <a href="https://huggingface.co/tiiuae">Falcon</a> use HuggingFace API Token, for OpenAI use OpenAI API Key")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)

.history/app_20230720144115.py

@@ -0,0 +1,61 @@
+import gradio as gr
+from src.main import ChatWrapper
+
+agent = ChatWrapper('openai', '')  # default agnet_state
+
+def update_agent(api_key: str, selection: str):
+    global agent
+    agent = ChatWrapper(chain_type=selection, api_key=api_key)
+    return agent # This is agent state
+
+def chat(message):
+    global agent
+    agent(message)  # Get a response to the current message
+    history = agent.history  # Access the entire chat history
+    return history, history # Return the history twice to update both the chatbot and the state
+
+block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
+
+with block:
+    with gr.Row():
+        gr.HTML("<h2><center>ConversationalChain App 🤖</center></h2> <br> For <a href='https://huggingface.co/tiiuae/falcon-7b-instruct'>Falcon</a> use HuggingFace API Token, for OpenAI use OpenAI API Key")
+        selection = gr.Dropdown(label="Select Agent", choices=["falcon", "openai"], default="openai")        
+        api_key_textbox = gr.Textbox(
+            label="API Key",
+            placeholder= "Paste Your API Key",
+            show_label=True,
+            lines=1,
+            type="password",
+        )
+
+    chatbot = gr.Chatbot()
+
+    with gr.Row():
+        message = gr.Textbox(
+            label="What's your question?",
+            placeholder="What's the answer to life, the universe, and everything?",
+            lines=1,
+        )
+        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,
+    )
+
+    gr.HTML("<center>View more at  <a href='https://ai.rohankataria.com'>ai.rohankataria.com</a></center>")
+
+    state = gr.State()
+    agent_state = gr.State()
+
+    submit.click(chat, inputs=[message], outputs=[chatbot, state])
+    message.submit(chat, inputs=[message], outputs=[chatbot, state])
+
+    api_key_textbox.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+    selection.change(update_agent, inputs=[api_key_textbox, selection], outputs=[agent_state])
+
+block.launch(debug=True)