Updates

app.py

@@ -1,74 +1,25 @@
 import streamlit as st
 
-from PIL import Image
-from tool_loader import ToolLoader
-from app_user_desc import app_user_desc
-from app_dev_desc import app_dev_desc
-from logger import log_response
-from logger import log_enabled
-from app_chat import app_chat
-import numpy as np
-import re,sys,unicodedata
-import logging
-
-
-from app_agent_config import AgentConfig 
-
-# Create an instance of AgentConfig ## holds all data and settings
-agent_config = AgentConfig()
+from controller import Controller
 
+from view.app_header import app_header
+from view.app_sidebar import app_sidebar
+from view.app_chat import app_chat
 
+## Streamlit configuration (holds the session and session history as well)
 st.set_page_config(
     page_title="Custom Transformers can realy do anything...",
-    page_icon="👋",
+    page_icon="👋" 
 )
 
-#####
-def on_close():
-    print("The modal was closed!")
-
-
-def open_modal():
-    print("Todo")
-   # st.modal("User Guide", "app_user_desc()")
-
-st.button("User Description", open_modal())
-# Define a callback function that will be called when the button is clicked
-#def open_modal():
-#    st.modal("User Guide", app_user_desc())
-
-# Create a button that opens the modal
-
-#######
-
-import pandas as pd
-from io import StringIO
-with st.sidebar:
-
-
-    st.header("Set Tools and Option. ")
-
-    with st.expander("Configure the agent and activate tools"):
-
-            agent_config.configure()
-
-    with st.expander("Set Content and Context"):
-
-            agent_config.content_and_context()
-         
-# Create a page with tabs
-#tabs = st.tabs(["Chat","User Description"])
-
-#with tabs[0]: 
-st.title("Hugging Face Agent and Tools")
+# Create an instance of Controller with agentConfig ## holds all data, config and settings
+controller = Controller()
 
-## LB https://huggingface.co/spaces/qiantong-xu/toolbench-leaderboard
+## sidebar for context & config
+app_sidebar(controller)
 
-st.markdown("Welcome to the Hugging Face Agent and Tools app! This app allows you to interact with various tools using the Hugging Face Inference API.  CustomTransformers can do anything \n🤪🤗😄🤗🤪.")
+## app header
+app_header(controller)
 
-    #st.markdown("Start to chat. e.g. Generate an image of a boat. This will make the agent use the tool text2image to generate an image. Set content, context, Inference URL , tools and logging in the sidebar.")
- 
-#with tabs[1]:
-   # app_user_desc()
-       
-app_chat(agent_config)
+## Main content the chat     
+app_chat(controller)

app_agent_config.py

@@ -1,11 +1,7 @@
 # app_agent_config.py
-import streamlit as st
-from tool_loader import ToolLoader
-from tool_config import tool_names
-from logger import log_enabled
-
-from PIL import Image 
-import numpy as np
+from utils.tool_loader import ToolLoader
+from utils.tool_config import tool_names
+from utils.logger import log_enabled
 
 class AgentConfig:
     def __init__(self):
@@ -17,75 +13,3 @@ class AgentConfig:
         self.context = ""
         self.tool_loader = ToolLoader(tool_names)
 
-    def configure(self):
-        st.markdown("Change the agent's configuration here.")
-        self.url_endpoint = st.selectbox("Select Inference URL", [
-            "https://api-inference.huggingface.co/models/bigcode/starcoder",
-            "https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
-            "https://api-inference.huggingface.co/models/gpt2"
-        ])
-        tool_loader = ToolLoader(tool_names)
-        self.log_enabled = st.checkbox("Enable Logging")
-        self.tool_checkboxes = [st.checkbox(f"{tool.name} --- {tool.description} ") for tool in tool_loader.tools]
-
-    def content_and_context(self):
-        self.context = st.text_area("Context")
-
-        self.image = st.camera_input("Take a picture")
-
-        img_file_buffer = st.file_uploader('Upload a PNG image', type='png')
-   
-        if img_file_buffer is not None:
-            image_raw = Image.open(img_file_buffer)
-            #global image
-            self.image = np.array(image_raw)
-            ######## 
-            st.image(agent_config.image)
-            
-        uploaded_file = st.file_uploader("Choose a pdf", type='pdf')
-        if uploaded_file is not None:
-            # To read file as bytes:
-            pdf_document = uploaded_file.getvalue() 
-            self.document = pdf_document
-            st.write(pdf_document)
-            
-        uploaded_txt_file = st.file_uploader("Choose a txt", type='txt')
-        if uploaded_txt_file is not None:
-            # To read file as bytes:
-            txt_document = uploaded_txt_file.getvalue()
-            self.document = txt_document
-            st.write(txt_document)
-            
-        uploaded_csv_file = st.file_uploader("Choose a csv", type='csv')
-        if uploaded_csv_file is not None:
-            # To read file as bytes:
-            csv_document = uploaded_csv_file.getvalue()
-            self.document = csv_document
-            st.write(csv_document)
-                        
-        uploaded_csv_file = st.file_uploader("Choose audio", type='wav')
-        if uploaded_csv_file is not None:
-            # To read file as bytes:
-            csv_document = uploaded_csv_file.getvalue()
-            self.document = csv_document
-            st.write(csv_document)
-            
-        uploaded_csv_file = st.file_uploader("Choose video", type='avi')
-        if uploaded_csv_file is not None:
-            # To read file as bytes:
-            csv_document = uploaded_csv_file.getvalue()
-            self.document = csv_document
-            st.write(csv_document)
-                    
-            # To convert to a string based IO:
-            #stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
-            #st.write(stringio)
-        
-            # To read file as string:
-            #string_data = stringio.read()
-            #st.write(string_data)
-        
-            # Can be used wherever a "file-like" object is accepted:
-            dataframe = pd.read_csv(uploaded_file)
-            st.write(dataframe)
-

controller.py

@@ -1,88 +1,56 @@
 import os
-from logger import log_response
-from custom_agent import CustomHfAgent 
-
+from app_agent_config import AgentConfig
+from utils.logger import log_response
+from model.custom_agent import CustomHfAgent 
+from model.conversation_chain_singleton import ConversationChainSingleton
    
-from langchain.vectorstores import FAISS
-from langchain.memory import ConversationBufferMemory
-from langchain.chains import ConversationalRetrievalChain, ConversationChain
-from langchain.llms import HuggingFaceHub
-
-
-image = []
-def handle_submission(user_message, selected_tools, url_endpoint, document, image, context):
-    
-    log_response("User input \n {}".format(user_message))
-    log_response("selected_tools \n {}".format(selected_tools))
-    log_response("url_endpoint \n {}".format(url_endpoint))
-    log_response("document \n {}".format(document))
-    log_response("image \n {}".format(image))
-    log_response("context \n {}".format(context))
-    
-    agent = CustomHfAgent(
-        url_endpoint=url_endpoint,
-        token=os.environ['HF_token'],
-        additional_tools=selected_tools,
-        input_params={"max_new_tokens": 192},
-    )
-
-    response = agent.chat(user_message,document=document,image=image, context = context)
-
-    log_response("Agent Response\n {}".format(response))
-
-    return response
-
-def cut_text_after_keyword(text, keyword):
-    index = text.find(keyword)
-    if index != -1:
-        return text[:index].strip()
-    return text
-
-
-
 
-def handle_submission_chat(user_message, response):
-    # os.environ['HUGGINGFACEHUB_API_TOKEN'] = os.environ['HF_token']
-    agent_chat_bot = ConversationChainSingleton().get_conversation_chain()    
 
-    if response is not None:
-        text = agent_chat_bot.predict(input=user_message + response)
-    else:
-        text = agent_chat_bot.predict(input=user_message)
+class Controller:
+    def __init__(self):
+        self.agent_config = AgentConfig()
 
-    result = cut_text_after_keyword(text, "Human:")
-    print(result)
+    image = []
+    def handle_submission(user_message, selected_tools, url_endpoint, document, image, context):
+        
+        log_response("User input \n {}".format(user_message))
+        log_response("selected_tools \n {}".format(selected_tools))
+        log_response("url_endpoint \n {}".format(url_endpoint))
+        log_response("document \n {}".format(document))
+        log_response("image \n {}".format(image))
+        log_response("context \n {}".format(context))
+        
+        agent = CustomHfAgent(
+            url_endpoint=url_endpoint,
+            token=os.environ['HF_token'],
+            additional_tools=selected_tools,
+            input_params={"max_new_tokens": 192},
+        )
 
-    return result
+        response = agent.chat(user_message,document=document,image=image, context = context)
 
-class ConversationChainSingleton:
-    _instance = None
+        log_response("Agent Response\n {}".format(response))
 
-    def __new__(cls, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super(ConversationChainSingleton, cls).__new__(cls)
-            # Initialize your conversation chain here
-            cls._instance.conversation_chain = get_conversation_chain()
-        return cls._instance
+        return response
 
-    def get_conversation_chain(self):
-        return self.conversation_chain
+    def cut_text_after_keyword(text, keyword):
+        index = text.find(keyword)
+        if index != -1:
+            return text[:index].strip()
+        return text
 
 
-def get_conversation_chain( ):
-    """
-    Create a conversational retrieval chain and a language model.
+    def handle_submission_chat(user_message, response):
+        # os.environ['HUGGINGFACEHUB_API_TOKEN'] = os.environ['HF_token']
+        agent_chat_bot = ConversationChainSingleton().get_conversation_chain()    
 
-    """
+        if response is not None:
+            text = agent_chat_bot.predict(input=user_message + response)
+        else:
+            text = agent_chat_bot.predict(input=user_message)
 
-    llm = HuggingFaceHub(
-        repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
-        model_kwargs={"max_length": 1048, "temperature":0.2, "max_new_tokens":256, "top_p":0.95, "repetition_penalty":1.0},
-    )
-    # llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
+        result = cut_text_after_keyword(text, "Human:")
+       
+        print(result)
 
-    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-    conversation_chain = ConversationChain(
-        llm=llm, verbose=True, memory=ConversationBufferMemory()
-    )
-    return conversation_chain
+        return result

model/conversation_chain_singleton.py

@@ -0,0 +1,36 @@
+from langchain.vectorstores import FAISS
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain, ConversationChain
+from langchain.llms import HuggingFaceHub
+
+class ConversationChainSingleton:
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if not cls._instance:
+            cls._instance = super(ConversationChainSingleton, cls).__new__(cls)
+            # Initialize your conversation chain here
+            cls._instance.conversation_chain = get_conversation_chain()
+        return cls._instance
+
+    def get_conversation_chain(self):
+        return self.conversation_chain
+
+
+    def get_conversation_chain( ):
+        """
+        Create a conversational retrieval chain and a language model.
+
+        """
+
+        llm = HuggingFaceHub(
+            repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+            model_kwargs={"max_length": 1048, "temperature":0.2, "max_new_tokens":256, "top_p":0.95, "repetition_penalty":1.0},
+        )
+        # llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
+
+        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        conversation_chain = ConversationChain(
+            llm=llm, verbose=True, memory=memory
+        )
+        return conversation_chain

custom_agent.py → model/custom_agent.py

@@ -5,7 +5,7 @@ import io
 import requests
 import time
 from transformers import Agent
-from logger import log_response
+from utils.logger import log_response
 
 import time  
 import torch

tool_loader.py → utils/tool_loader.py

@@ -2,8 +2,8 @@
 
 import logging
 from transformers import load_tool
-from logger import log_response  # Import the logger
-from tool_config import tool_names   
+from utils.logger import log_response  # Import the logger
+from utils.tool_config import tool_names   
 
 class ToolLoader:
     def __init__(self, tool_names):

app_chat.py → view/app_chat.py

@@ -1,33 +1,12 @@
-
 import streamlit as st
-from controller import handle_submission, handle_submission_chat
-# For Altair charts
-import altair as alt
+import pandas as pd   
+import matplotlib.figure   
+ 
 from PIL import Image
 from pydub import AudioSegment
-import IPython
-import soundfile as sf
-from app_agent_config import AgentConfig
-from tool_loader import ToolLoader
-import re,sys,unicodedata
-
-
-import pandas as pd  # If you're working with DataFrames
-import matplotlib.figure  # If you're using matplotlib figures
-import numpy as np
-
-# For Bokeh charts
-from bokeh.models import Plot
-
-# For Plotly charts
-import plotly.express as px
 
-# For Pydeck charts
-import pydeck as pdk
-
-# Call app_agent_config to set the global variables
-
-def app_chat(agent_config):
+def app_chat(controller):
+    agent_config = controller.agent_config
     # Chat code (user input, agent responses, etc.)
     if "messages" not in st.session_state:
         st.session_state.messages = []
@@ -37,84 +16,90 @@ def app_chat(agent_config):
         with st.chat_message(message["role"]):
             st.markdown(message["content"])
     
-    #with st.chat_message("assistant"):
-    #    st.markdown("Hello there! How can I assist you today?")
-    
     if user_message := st.chat_input("Enter message"):
         st.chat_message("user").markdown(user_message)
         st.session_state.messages.append({"role": "user", "content": user_message, "avatar": "🤗"})
     
         selected_tools = [agent_config.tool_loader.tools[idx] for idx, checkbox in enumerate(agent_config.tool_checkboxes) if checkbox]
-        # Handle submission with the selected inference URL
-        #app_agent_config()
 
         response = ""
         chat_respone = ""
         with st.spinner('Please stand by ...'):
+            response = controller.handle_submission(user_message, selected_tools, agent_config.url_endpoint, agent_config.document, agent_config.image, agent_config.context)
 
-            response = handle_submission(user_message, selected_tools, agent_config.url_endpoint, agent_config.document, agent_config.image, agent_config.context)
-    
         with st.chat_message("assistant"):
             if response is None:
-                chat_respone = handle_submission_chat(user_message, response)
+                chat_respone = controller.handle_submission_chat(user_message, response)
                 st.write(chat_respone)
                # st.warning("The agent's response is None. Please try again. Generate an image of a flying uncormn.")
             elif isinstance(response, Image.Image):
                 agent_config.image = response
-                chat_respone = handle_submission_chat(user_message, "No context . Created an image.")
+                chat_respone = controller.handle_submission_chat(user_message, "No context . Created an image.")
                 st.write(chat_respone)
                 st.image(response)
             elif isinstance(response, AudioSegment):
                 agent_config.audio = response
-                chat_respone = handle_submission_chat(user_message, "Agent Tool created audio file.")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool created audio file.")
                 st.write(chat_respone)
                 st.audio(response)
             elif isinstance(response, int): 
-                chat_respone = handle_submission_chat(user_message, response)
+                chat_respone = controller.handle_submission_chat(user_message, response)
                 st.write(chat_respone)
                 st.markdown(response)
             elif isinstance(response, str):
                 if "emojified_text" in response: 
-                    chat_respone = handle_submission_chat(user_message, "Agent Tool created the text with emojies.")
+                    chat_respone = controller.handle_submission_chat(user_message, "Agent Tool created the text with emojies.")
                     st.write(chat_respone)
                     st.markdown(f"{response['emojified_text']}")
                 else:
-                    chat_respone = handle_submission_chat(user_message, response)
+                    chat_respone = controller.handle_submission_chat(user_message, response)
                     st.write(chat_respone)
                     st.markdown(response)
             elif isinstance(response, list):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a list")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a list")
                 for item in response:
                     st.markdown(item)  # Assuming the list contains strings
+                st.write(chat_respone)
             elif isinstance(response, pd.DataFrame):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a pd.DataFrame")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.DataFrame")
+                st.write(chat_respone) 
                 st.dataframe(response)
+               
             elif isinstance(response, pd.Series):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a pd.Series")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.Series")
+                st.write(chat_respone) 
                 st.table(response.iloc[0:10])
             elif isinstance(response, dict):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a dict")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a dict")
+                st.write(chat_respone) 
                 st.json(response)
             elif isinstance(response, st.graphics_altair.AltairChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a st.graphics_altair.AltairChart")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a st.graphics_altair.AltairChart")
+                st.write(chat_respone) 
                 st.altair_chart(response)
             elif isinstance(response, st.graphics_bokeh.BokehChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a st.graphics_bokeh.BokehChart")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a st.graphics_bokeh.BokehChart")
+                st.write(chat_respone) 
                 st.bokeh_chart(response)
             elif isinstance(response, st.graphics_graphviz.GraphvizChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a st.graphics_graphviz.GraphvizChart")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a st.graphics_graphviz.GraphvizChart")
+                st.write(chat_respone) 
                 st.graphviz_chart(response)
             elif isinstance(response, st.graphics_plotly.PlotlyChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a st.graphics_plotly.PlotlyChart")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a st.graphics_plotly.PlotlyChart")
+                st.write(chat_respone) 
                 st.plotly_chart(response)
             elif isinstance(response, st.graphics_pydeck.PydeckChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a  st.graphics_pydeck.PydeckChart")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a  st.graphics_pydeck.PydeckChart")
+                st.write(chat_respone) 
                 st.pydeck_chart(response)
             elif isinstance(response, matplotlib.figure.Figure):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a matplotlib.figure.Figure")
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a matplotlib.figure.Figure")
+                st.write(chat_respone) 
                 st.pyplot(response)
-            elif isinstance(response, streamlit.graphics_vega_lite.VegaLiteChart):
-                chat_respone = handle_submission_chat(user_message, "Agent Tool produced a VegaLiteChart")
+            elif isinstance(response, st.graphics_vega_lite.VegaLiteChart):
+                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a VegaLiteChart")
+                st.write(chat_respone) 
                 st.vega_lite_chart(response)
             else:
                 st.warning("Unrecognized response type. Please try again. e.g. Generate an image of a flying horse.")

view/app_header.py

@@ -0,0 +1,10 @@
+import streamlit as st
+
+
+def app_header(controller):
+    st.title("Hugging Face Agent and Tools")
+
+    ## LB https://huggingface.co/spaces/qiantong-xu/toolbench-leaderboard
+
+    st.markdown("Welcome to the Hugging Face Agent and Tools app! This app allows you to interact with various tools using the Hugging Face Inference API.  CustomTransformers can do anything \n🤪🤗😄🤗🤪.")
+

view/app_sidebar.py

@@ -0,0 +1,84 @@
+
+import streamlit as st
+from PIL import Image 
+import numpy as np
+import pandas as pd
+
+def app_sidebar(controller):
+
+    with st.sidebar:
+        st.header("Set Tools and Option. ")
+        with st.expander("Configure the agent and tools"):
+                configure(controller.agent_config)
+        with st.expander("Set the Content and Context"):
+                content_and_context(controller.agent_config)
+
+    def configure(agent_config):
+        st.markdown("Change the agent's configuration here.")
+
+        agent_config.url_endpoint = st.selectbox("Select Inference URL", [
+            "https://api-inference.huggingface.co/models/bigcode/starcoder",
+            "https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
+            "https://api-inference.huggingface.co/models/gpt2"
+        ])
+       
+        agent_config.log_enabled = st.checkbox("Enable Logging")
+
+        agent_config.tool_checkboxes = [st.checkbox(f"{tool.name} --- {tool.description} ") for tool in agent_config.tool_loader.tools]
+
+    def content_and_context(agent_config):
+        agent_config.context = st.text_area("Context")
+
+        agent_config.image = st.camera_input("Take a picture")
+
+        img_file_buffer = st.file_uploader('Upload a PNG image', type='png')
+   
+        if img_file_buffer is not None:
+            image_raw = Image.open(img_file_buffer)
+            #global image
+            agent_config.image = np.array(image_raw)
+            ######## 
+            st.image(agent_config.image)
+            
+        uploaded_file = st.file_uploader("Choose a pdf", type='pdf')
+        if uploaded_file is not None:
+            # To read file as bytes:
+            agent_config.document = uploaded_file.getvalue()  
+            st.write(agent_config.document)
+            
+        uploaded_txt_file = st.file_uploader("Choose a txt", type='txt')
+        if uploaded_txt_file is not None:
+            # To read file as bytes:
+            agent_config.document = uploaded_txt_file.getvalue() 
+            st.write(agent_config.document)
+            
+        uploaded_csv_file = st.file_uploader("Choose a csv", type='csv')
+        if uploaded_csv_file is not None:
+            # To read file as bytes:
+            agent_config.document = uploaded_csv_file.getvalue() 
+            st.write(agent_config.document)
+                        
+        uploaded_csv_file = st.file_uploader("Choose audio", type='wav')
+        if uploaded_csv_file is not None:
+            # To read file as bytes:
+            agent_config.document = uploaded_csv_file.getvalue() 
+            st.write(agent_config.document)
+            
+        uploaded_csv_file = st.file_uploader("Choose video", type='avi')
+        if uploaded_csv_file is not None:
+            # To read file as bytes:
+            agent_config.document = uploaded_csv_file.getvalue() 
+            st.write(agent_config.document)
+                    
+            # To convert to a string based IO:
+            #stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
+            #st.write(stringio)
+        
+            # To read file as string:
+            #string_data = stringio.read()
+            #st.write(string_data)
+        
+            # Can be used wherever a "file-like" object is accepted:
+            dataframe = pd.read_csv(uploaded_file)
+            st.write(dataframe)
+