Gradio + Streamlit

Dockerfile

@@ -28,9 +28,8 @@ ENV HOME=/home/user \
 # Set the working directory to the user's home directory
 WORKDIR $HOME/app
 
-# Expose the secret HUGGINGFACEHUB_API_TOKEN at buildtime and use its value to clone the repo 
-RUN --mount=type=secret,id=HUGGINGFACEHUB_API_TOKEN,mode=0444,required=true \
-    git clone --depth 1 https://github.com/nikhilkomakula/llm-rag-op-chatbot.git $HOME/app
+# Clone the Git repo 
+RUN git clone --depth 1 https://github.com/nikhilkomakula/llm-rag-op-chatbot.git $HOME/app
 
 # Use ENTRYPOINT to specify the command to run when the container starts
-ENTRYPOINT ["python", "app.py"]
+ENTRYPOINT ["python", "gradio_ui.py"]

README.md

@@ -113,6 +113,14 @@ docker ps -a
 docker logs -f llm-rag-op-chatbot
 ```
 
+## REST API:
+
+**Note:** Navigate to the chat interface UI in the browser and locate `Use via API` and click on it. A fly over opens on the right hand side. Capture the URL under the title named `API documentation`.
+
+* **URL:** `<http|https>`://`<hostname`:`<port>`/run/chat
+* **METHOD:** POST
+* **BODY:** { "data": ["`<query>`", ""] }
+
 ## Technologies Used:
 
 * **PDF Parser :** PyMuPDFLoader

app.py

@@ -1,23 +1,29 @@
 # import libraries
 import sys
-from dotenv import find_dotenv, load_dotenv
+import subprocess
 
-# import functions
-from src.test.eval_rag import evaluate_rag
-from src.ui.chat_interface import create_chatinterface
-from src.generation.generate_response import get_qa_chain, set_global_qa_chain, generate_response
+# Define functions for Gradio and Streamlit interfaces
+def run_gradio_interface():
+    subprocess.run(["python", "gradio_ui.py"])
 
-# find .env automatically by walking up directories until it's found, then
-# load up the .env entries as environment variables
-load_dotenv(find_dotenv())
+def run_streamlit_interface():
+    subprocess.run(["streamlit", "run", "streamlit_ui.py"])
+    
+def run_rag_evaluate():
+    subprocess.run(["python", "eval.py"])
 
-if __name__ == "__main__":
-
-    # get the qa chain
-    qa_chain = get_qa_chain()
-
-    if len(sys.argv) > 1:
-        evaluate_rag("qa_chain", qa_chain)
+# Main function to determine which interface to run
+def main():
+    if "-gradio" in sys.argv:
+        print("Initializing Gradio Interface!")
+        run_gradio_interface()
+    elif "-streamlit" in sys.argv:
+        print("Initializing Streamlit Interface!")
+        run_streamlit_interface()
     else:
-        set_global_qa_chain(qa_chain)
-        create_chatinterface(generate_response).launch(server_name="0.0.0.0", server_port=7860)
+        print("Running RAG Evaluation!")
+        run_rag_evaluate()
+
+# Run the main function
+if __name__ == "__main__":
+    main()

eval.py

@@ -0,0 +1,21 @@
+# import libraries
+from dotenv import find_dotenv, load_dotenv
+
+# import functions
+from src.test.eval_rag import evaluate_rag
+from src.generation.generate_response import get_qa_chain
+
+def main():
+
+    # find .env automatically by walking up directories until it's found, then
+    # load up the .env entries as environment variables
+    load_dotenv(find_dotenv())
+
+    # get the qa chain
+    qa_chain = get_qa_chain()
+    
+    # evaluate the qa chain
+    evaluate_rag("qa_chain", qa_chain)
+
+if __name__ == "__main__":
+    main()

gradio_ui.py

@@ -0,0 +1,24 @@
+# import libraries
+from dotenv import find_dotenv, load_dotenv
+
+# import functions
+from src.ui.gradio_chat_interface import create_gradio_chatinterface
+from src.generation.generate_response import get_qa_chain, set_global_qa_chain, generate_response_gradio
+
+def main():
+
+    # find .env automatically by walking up directories until it's found, then
+    # load up the .env entries as environment variables
+    load_dotenv(find_dotenv())
+
+    # get the qa chain
+    qa_chain = get_qa_chain()
+
+    # set the global qa chain
+    set_global_qa_chain(qa_chain)
+    
+    # initiate the chat interface
+    create_gradio_chatinterface(generate_response_gradio).launch(server_name="0.0.0.0", server_port=7860)
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -7,4 +7,5 @@ pymupdf==1.23.26
 sentence-transformers==2.5.1
 tensorflow==2.16.1
 gradio==4.21.0
-pandas==2.2.1
+pandas==2.2.1
+streamlit==1.32.2

src/generation/generate_response.py

@@ -1,9 +1,11 @@
 # import libraries
 import time
+from typing import Optional
 from src.retrieval.retriever_chain import get_base_retriever, load_hf_llm, create_qa_chain
 
 # constants
-HF_MODEL = "huggingfaceh4/zephyr-7b-beta"  # "mistralai/Mistral-7B-Instruct-v0.2" # "google/gemma-7b"
+HF_MODEL        = "huggingfaceh4/zephyr-7b-beta"  # "mistralai/Mistral-7B-Instruct-v0.2" # "google/gemma-7b"
+EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5"
 
 
 # get the qa chain
@@ -16,7 +18,7 @@ def get_qa_chain():
     """
 
     # get retriever
-    retriever = get_base_retriever(k=4, search_type="mmr")
+    retriever = get_base_retriever(embedding_model=EMBEDDING_MODEL, k=4, search_type="mmr")
 
     # instantiate llm
     llm = load_hf_llm(repo_id=HF_MODEL, max_new_tokens=512, temperature=0.4)
@@ -28,17 +30,22 @@ def get_qa_chain():
 
 
 def set_global_qa_chain(local_qa_chain):
+    """
+    Sets the Global QA Chain.
+
+    Args:
+        local_qa_chain: Local QA Chain.
+    """
     global global_qa_chain
     global_qa_chain = local_qa_chain
-
-
-# function to generate response
-def generate_response(message, history):
+    
+# function to generate streamlit response
+def generate_response(query: str):
     """
     Generates response based on the question being asked.
 
     Args:
-        message (str): Question asked by the user.
+        query (str): Question asked by the user.
         history (dict): Chat history. NOT USED FOR NOW.
 
     Returns:
@@ -46,12 +53,48 @@ def generate_response(message, history):
     """
 
     # invoke chain
-    print("Question:", message)
+    print("*" * 100)
+    print("Question:", query)
     start_time = time.time()
-    query = message
     response = global_qa_chain.invoke(query)
     print("Answer:", response)
     end_time = time.time()
     print("Response Time:", "{:.2f}".format(round(end_time - start_time, 2)))
-
+    print("*" * 100)
     return response
+
+# function to generate streamlit response
+def generate_response_streamlit(message: str, history: Optional[dict]):
+    """
+    Generates response based on the question being asked.
+
+    Args:
+        message (str): Question asked by the user.
+        history (dict): Chat history. NOT USED FOR NOW.
+
+    Returns:
+        str: Returns the generated response.
+    """
+
+    response = generate_response(message)
+    for word in response.split():
+        yield word + " "
+        time.sleep(0.05)
+        
+# function to generate response
+def generate_response_gradio(message: str, history: Optional[dict]):
+    """
+    Generates response based on the question being asked.
+
+    Args:
+        message (str): Question asked by the user.
+        history (dict): Chat history. NOT USED FOR NOW.
+
+    Returns:
+        str: Returns the generated response.
+    """
+
+    response = generate_response(message)
+    for i in range(len(response)):
+        time.sleep(0.01)
+        yield response[: i+1]

src/indexing/build_indexes.py

@@ -1,11 +1,11 @@
 # import libraries
 import os
-from typing import List, Optional
+from typing import List
 from transformers import AutoTokenizer
 from langchain_community.vectorstores import Chroma
 from sentence_transformers import SentenceTransformer
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain_community.embeddings import HuggingFaceBgeEmbeddings
+from langchain_community.embeddings import HuggingFaceBgeEmbeddings, HuggingFaceInferenceAPIEmbeddings
 from langchain.docstore.document import Document
 
 # import functions
@@ -13,13 +13,15 @@ from ..data.load_dataset import load_documents
 
 # constants
 INDEX_DIR = "indexes/"
-EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5"
 
 
 # instantiate embedding model
-def load_embedding_model():
+def load_embedding_model(embedding_model):
     """
     Load the embedding model.
+    
+    Args:
+        embedding_model(str): Hugging Face Embedding Model name.
 
     Returns:
         HuggingFaceBgeEmbeddings: Returns the embedding model.
@@ -32,7 +34,7 @@ def load_embedding_model():
     print("device:", device)
 
     hf_bge_embeddings = HuggingFaceBgeEmbeddings(
-        model_name=EMBEDDING_MODEL,
+        model_name=embedding_model,
         model_kwargs={"device": device},
         encode_kwargs={
             "normalize_embeddings": True # set True to compute cosine similarity
@@ -41,17 +43,31 @@ def load_embedding_model():
 
     # To get the value of the max sequence_length, we will query the underlying `SentenceTransformer` object used in the RecursiveCharacterTextSplitter.
     print(
-        f"Model's maximum sequence length: {SentenceTransformer(EMBEDDING_MODEL).max_seq_length}"
+        f"Model's maximum sequence length: {SentenceTransformer(embedding_model).max_seq_length}"
     )
 
     return hf_bge_embeddings
 
+# instantiate embedding model
+def load_inference_embedding_model(embedding_model):
+    """
+    Load the inference embedding model.
+    
+    Args:
+        embedding_model(str): Hugging Face Embedding Model name.
+
+    Returns:
+        HuggingFaceInferenceAPIEmbeddings: Returns the inference embedding model.
+    """
+    hf_inference_bge_embeddings = HuggingFaceInferenceAPIEmbeddings(model_name=embedding_model, api_key=os.environ["HUGGINGFACEHUB_API_TOKEN"])
+    return hf_inference_bge_embeddings
+
 
 # split documents
 def chunk_documents(
     chunk_size: int,
     knowledge_base: List[Document],
-    tokenizer_name: Optional[str] = EMBEDDING_MODEL,
+    tokenizer_name: str,
 ) -> List[Document]:
     """
     Split documents into chunks of maximum size `chunk_size` tokens and return a list of documents.
@@ -90,9 +106,12 @@ def chunk_documents(
 
 
 # generate indexes
-def generate_indexes():
+def generate_indexes(embedding_model):
     """
     Generates indexes.
+    
+    Args:
+        embedding_model(str): Hugging Face Embedding Model name.
 
     Returns:
         ChromaCollection: Returns vector store.
@@ -104,16 +123,16 @@ def generate_indexes():
     # chunk documents to honor the context length
     chunked_documents = chunk_documents(
         SentenceTransformer(
-            EMBEDDING_MODEL
+            embedding_model
         ).max_seq_length,  # We choose a chunk size adapted to our model
         documents,
-        tokenizer_name=EMBEDDING_MODEL,
+        tokenizer_name=embedding_model,
     )
 
     # save indexes to disk
     vector_store = Chroma.from_documents(
         documents=chunked_documents,
-        embedding=load_embedding_model(),
+        embedding=load_embedding_model(embedding_model),
         collection_metadata={"hnsw:space": "cosine"},
         persist_directory=INDEX_DIR,
     )
@@ -122,24 +141,30 @@ def generate_indexes():
 
 
 # load indexes from disk
-def load_indexes():
+def load_indexes(embedding_model):
     """
     Loads indexes into memory.
+    
+    Args:
+        embedding_model(str): Hugging Face Embedding Model name.
 
     Returns:
         ChromaCollection: Returns vector store.
     """
 
     vector_store = Chroma(
-        persist_directory=INDEX_DIR, embedding_function=load_embedding_model()
+        persist_directory=INDEX_DIR, embedding_function=load_inference_embedding_model(embedding_model)
     )
     return vector_store
 
 
 # retrieve vector store
-def retrieve_indexes():
+def retrieve_indexes(embedding_model):
     """
     Retrieves indexes.
+    
+    Args:
+        embedding_model(str): Hugging Face Embedding Model name.
 
     Returns:
         ChromaCollection: Returns vector store.
@@ -147,7 +172,7 @@ def retrieve_indexes():
 
     if [f for f in os.listdir(INDEX_DIR) if not f.startswith(".")] == []:
         print("Generating indexes...")
-        return generate_indexes()
+        return generate_indexes(embedding_model)
     else:
         print("Loading existing indexes!")
-        return load_indexes()
+        return load_indexes(embedding_model)

src/retrieval/retriever_chain.py

@@ -10,11 +10,12 @@ from ..indexing.build_indexes import retrieve_indexes
 
 
 # instantiate base retriever
-def get_base_retriever(k=4, search_type="mmr"):
+def get_base_retriever(embedding_model, k=4, search_type="mmr"):
     """
     Instantiates base retriever.
 
     Args:
+        embedding_model(str): Hugging Face Embedding Model name.
         k (int, optional): Top k results to retrieve. Defaults to 4.
         search_type (str, optional): Search type (mmr or similarity). Defaults to 'mmr'.
 
@@ -23,7 +24,7 @@ def get_base_retriever(k=4, search_type="mmr"):
     """
 
     # get the vector store of indexes
-    vector_store = retrieve_indexes()
+    vector_store = retrieve_indexes(embedding_model)
 
     base_retriever = vector_store.as_retriever(
         search_type=search_type, search_kwargs={"k": k}

src/test/eval_rag.py

@@ -56,6 +56,12 @@ def evaluate_rag(chain_name, rag_chain):
             "Response": answer,
             "Time": "{:.2f}".format(round(end_time - start_time, 2)),
         }
+        
+        print("*" * 100)
+        print("Question:", question)
+        print("Answer:", answer)
+        print("Response Time:", "{:.2f}".format(round(end_time - start_time, 2)))
+        print("*" * 100)
 
         df = pd.concat([df, pd.DataFrame.from_records([row])])
 

src/test/eval_results_20240325111437.csv

@@ -0,0 +1,86 @@
+Chain,Question,Response,Time
+qa_chain,What is FastMap?," FastMap is a productivity tool that integrates with IBM OpenPages with Watson's export feature and automates the process of importing and batch processing object data into OpenPages with Watson. It uses a data load template, typically in Microsoft Excel format, to capture data for import. When importing data into OpenPages with Watson, FastMap validates the data and, if no errors are found, populates the repository with the new or updated records. It supports the import of various types of objects, but not File and Signature objects or the Comment field's system field. Some general rules apply when entering object data into a FastMap data load template, such as associating child objects using specific columns and not importing certain fields like read-only fields or those not in the Admin view for the object. Additionally, FastMap import does not evaluate field dependency rules, allowing users to stage data requiring them to enter required data during subsequent updates. Overall, FastMap helps streamline the process of importing large amounts of data into OpenPages with Watson, reducing manual input and increasing efficiency.",4.01
+qa_chain,What is a Role Template?," A Role Template in IBM OpenPages with Watson solutions is a predefined set of permissions and access controls that determine the level of access and functionality granted to a user in the system. It includes application permissions, feature access, and Object Access Controls (OACs) for specific object types. Role Templates help simplify the process of managing user access and ensure consistent security policies across the organization. By assigning a Role Template to a user, you can quickly and easily grant them the required permissions and access levels for their job function.",1.85
+qa_chain,What is the purpose of Object Reset?," The purpose of Object Reset in IBM OpenPages with Watson is to allow users to efficiently update multiple objects at once based on predefined rules. This feature helps to simplify repetitive data entry tasks and reduce errors associated with manually updating large numbers of objects. It also provides flexibility in terms of what objects are affected by the reset, as users can choose specific business entities and define rulesets to control the behavior of the reset. Overall, Object Reset helps to streamline data management processes and improve efficiency in IBM OpenPages with Watson.",2.56
+qa_chain,What is the purpose of Reporting Periods?," Reporting periods in IBM OpenPages with Watson serve as ""snapshots"" of the current state of the repository during specific points in time, typically at the end of a quarter or year. These periods allow organizations to archive and report on historical data while maintaining the ability to view and analyze current data. Reporting periods facilitate compliance and regulatory requirements, provide insights into trends and patterns, and enable comparisons between different periods. Additionally, they can be used to automate object resets, which modify object properties based on predefined rulesets. Overall, reporting periods help organizations manage and analyze their data more efficiently and effectively.",2.05
+qa_chain,List the system variables used in Expressions.,"1. $APPLICATION_URL$: A URL for OpenPages.
+    2. $COGNOS_URL$: A URL for IBM Cognos Analytics.
+    3. $ApplicationText/application text key$): Application text content.
+    4. $TASK_VIEW_URL$): A URL to an object task view.
+    5. $System Fields:Task View URL$): Deprecated. Use [$TASK_VIEW_URL$].
+    6. $Setting/OpenPages/...$): A registry setting value.
+    7. $END_USER$): The user name of the signed on user.
+    8. $TODAY$): Today's date.
+    9. $DaysFromNow/field group:field name$): A day count from today to a given date.
+    10. ${asset.id}$: Inserts the identifier of the underlying asset.
+    11. ${asset.name}$: Inserts the asset name of the underlying asset.
+    12. ${asset.description}$: Inserts the asset description of the underlying asset.",2.46
+qa_chain,Provide the steps to configure Watson Assistant in OpenPages?," Unfortunately, I don't have access to your specific environment or installation details. However, here are the general steps to configure Watson Assistant in OpenPages:
+
+1. Ensure that you have a Watson Assistant service instance created and configured with the necessary intents and entities.
+
+2. In OpenPages, go to the Administration Console > Integrations > Watson Assistant.
+
+3. Click on the ""Add"" button to create a new Watson Assistant integration.
+
+4. Enter a name and description for the integration and select the appropriate Watson Assistant service instance from the list.
+
+5. Configure the authentication settings by providing the API key and URL of your Watson Assistant service.
+
+6. Select the appropriate language and version of Watson Assistant.
+
+7. Map the Watson Assistant intents and entities to the corresponding OpenPages business objects and fields.
+
+8. Save the configuration and test the integration by running a sample request through the Watson Assistant REST API.
+
+9. Verify that the response is correctly mapped to the appropriate OpenPages business object and field values.
+
+10. Deploy the integration to make it available to users in the OpenPages application.
+
+Note: These steps may vary depending on your specific implementation and version of OpenPages and Watson Assistant. It's recommended to refer to the official documentation for detailed instructions and best practices.",1.94
+qa_chain,What is the difference between PRE and POST position in Triggers?,"
+    In Triggers, the position ""PRE"" refers to events that occur prior to the actual execution of an operation by the system. These triggers allow for additional processing of business logic before the operation is carried out. For example, during the creation of a GRC object, a PRE trigger has access to all the necessary information about the object to be created, but the system has not yet taken action to create the object and persist its values. PRE triggers are mandatory for deletions, associations, and disassociations.
+
+    On the other hand, the position ""POST"" refers to events that occur after an operation has been performed by the system but before the transaction is committed. These triggers provide further processing of additional business logic after the operation has been completed. POST triggers are mandatory for creating and updating operations.
+
+    In summary, PRE triggers execute before the operation takes place, while POST triggers execute after the operation has been completed.",2.56
+qa_chain,What are the features of Operational Risk Management in OpenPages?,"1. Loss Events: This feature allows organizations to track, assess, and manage both internal and external events that could lead to operational losses. Multiple impact events and recoveries associated with operational losses can also be managed through this feature.
+
+2. Risk and Control Self Assessments (RCSA): This feature helps in identifying, measuring, and mitigating risks, as well as testing and documenting internal controls.
+
+3. Key Risk Indicators (KRIs) and Key Performance Indicators (KPIs): These features enable tracking of performance metrics that may indicate the presence or state of a risk condition or trend.
+
+4. Scenario Analysis: This feature is used to identify and measure specific types of risks, particularly low-frequency, high-severity events.
+
+5. External Loss Events: This feature allows for the import of loss data from various sources such as IBM FIRST Risk Case Studies, ORX, and ORIC loss databases for scenario analysis, benchmarking, and report generation.
+
+6. Issue Management and Remediation (IMR): This feature includes issue creation and assignment, action creation and assignment, remediation performance, issue closure, and reporting.
+
+7. Reporting, Monitoring, and Analytics: This feature provides reporting, monitoring, and analytics capabilities for operational risk management.
+
+Note: The above features are part of IBM OpenPages Operational Risk Management. Other related features like Regulatory Compliance Management, Third Party Risk Management, and IT Governance with RiskLens are also available in IBM OpenPages.",2.56
+qa_chain,What are the different permissions that can be delegated to a user group administrator?," There are six security management permissions that can be delegated to a user group administrator: Manage, Lock, Unlock, Reset Password, Assign Role, and Browse. These permissions allow the administrator to perform various user-provisioning functions such as creating, modifying, and associating users and groups, locking and unlocking user accounts, resetting passwords, assigning roles to users and groups, and browsing users and groups within their respective groups. The specific permissions required for each user-provisioning function are listed in Table 38 provided in the text material. It's important to note that these permissions should be granted carefully and only to trusted individuals as they have significant impact on the overall security and functionality of the system.",8.57
+qa_chain,What are the different access controls available for non-participants for a standard stage within a workflow?," Table 142 in the text provides the different access controls available for non-participants for a standard stage within a workflow:
+
+     Access control for the stage
+     Can view the object when it’s at this stage
+     Can edit the object when it’s at this stage
+     Can see the Actions button in views
+     Strict
+     No
+     No
+     No
+     Read
+     Yes
+     No
+     No
+     Open
+     Depends on standard access controls
+     Depends on standard access controls
+     No
+     No Override
+     Depends on standard access controls
+     Depends on standard access controls
+     Yes
+
+     Note: For workflow participants (assignees, oversight users, and subscribers), the standard access controls apply, and they only know their part of the process. Non-participants may require additional access controls based on their roles and responsibilities within the organization. The ""Override"" option allows you to define whether to override these standard access controls for the workflow stage for non-participants.",41.15

src/ui/{chat_interface.py → gradio_chat_interface.py}

@@ -6,7 +6,7 @@ from src.test.eval_rag import load_eval_questions
 
 
 # create chatbot interface
-def create_chatinterface(generate_response):
+def create_gradio_chatinterface(generate_response):
     """
     Instantiates the gradio chat interface.
 

src/ui/streamlit_chat_interface.py

@@ -0,0 +1,47 @@
+# import libraries
+import streamlit as st
+
+# import functions
+from src.test.eval_rag import load_eval_questions
+        
+# initialize streamlit
+def create_streamlit_chatinterface(generate_response):
+    """
+    Instantiates the streamlit chat interface.
+
+    Args:
+        generate_response (callable): Function that generates the response.
+    """
+
+    st.title("OpenPages IntelliBot")
+    st.caption("Ask me about OpenPages (v9.0), its features, solutions / modules it offers and the trigger framework. Authored by Nikhil Komakula ([email protected]).")
+    st.divider()    
+
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    # Display chat messages from history on app rerun
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.markdown(message["content"])
+
+    # Accept user input
+    if prompt := st.chat_input("Type your question here!"):
+        # Add user message to chat history
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        # Display user message in chat message container
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        # Display assistant response in chat message container
+        with st.chat_message("assistant"):
+            with st.spinner(""):
+                response = st.write_stream(generate_response(prompt, st.session_state.messages))
+                
+        # Add assistant response to chat history
+        st.session_state.messages.append({"role": "assistant", "content": response})
+
+    # option = st.selectbox("Examples:", tuple(load_eval_questions()))
+    # if option:
+    #     st.chat_message(option)

streamlit_ui.py

@@ -0,0 +1,24 @@
+# import libraries
+from dotenv import find_dotenv, load_dotenv
+
+# import functions
+from src.ui.streamlit_chat_interface import create_streamlit_chatinterface
+from src.generation.generate_response import get_qa_chain, set_global_qa_chain, generate_response_streamlit
+
+def main():
+
+    # find .env automatically by walking up directories until it's found, then
+    # load up the .env entries as environment variables
+    load_dotenv(find_dotenv())
+
+    # get the qa chain
+    qa_chain = get_qa_chain()
+
+    # set the global qa chain
+    set_global_qa_chain(qa_chain)
+    
+    # initiate the chat interface
+    create_streamlit_chatinterface(generate_response_streamlit)
+
+if __name__ == "__main__":
+    main()