update: update tools call function

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY = ''

.gitignore

@@ -0,0 +1 @@
+__pycache__

app.py

@@ -1,39 +1,72 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-"""
-For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-"""
-client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
-
-
-def respond(message,history: list[tuple[str, str]],system_message,max_tokens,temperature,top_p,):
-    messages = [{"role": "system", "content": system_message}]
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
-    messages.append({"role": "user", "content": message})
-    response = ""
-    for message in client.chat_completion(messages,max_tokens=max_tokens,stream=True,
-                                          temperature=temperature,top_p=top_p,):
-        token = message.choices[0].delta.content
-        response += token
-        yield response
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-demo = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(minimum=0.1,maximum=1.0,value=0.95,step=0.05,label="Top-p (nucleus sampling)",),
-    ],
-)
+import gradio
+from chatbot_agent import *
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
+# from huggingface_hub import InferenceClient
+# """
+# For more information on `huggingface_hub` Inference API support, please check the docs: 
+# https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+# """
+# client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
+
+
+# def respond(message,history: list[tuple[str, str]],system_message,max_tokens,temperature,top_p,):
+#     messages = [{"role": "system", "content": system_message}]
+#     for val in history:
+#         if val[0]:
+#             messages.append({"role": "user", "content": val[0]})
+#         if val[1]:
+#             messages.append({"role": "assistant", "content": val[1]})
+#     messages.append({"role": "user", "content": message})
+#     response = ""
+#     for message in client.chat_completion(messages,max_tokens=max_tokens,stream=True,
+#                                           temperature=temperature,top_p=top_p,):
+#         token = message.choices[0].delta.content
+#         response += token
+#         yield response
+
+# """
+# For information on how to customize the ChatInterface, peruse the gradio docs: 
+# https://www.gradio.app/docs/chatinterface
+# """
+# demo = gr.ChatInterface(
+#     respond,
+#     additional_inputs=[
+#         gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
+#         gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+#         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+#         gr.Slider(minimum=0.1,maximum=1.0,value=0.95,step=0.05,label="Top-p (nucleus sampling)",),
+#     ],
+# )
+
+
+def message_and_history(input, history):
+    history = history or []
+    s = list(sum(history, ()))
+    s.append(input)
+    inp = ' '.join(s)
+    output = chatbot_llm.ask_chatbot(user_message = inp)
+    print(output)
+    history.append((input, output))
+    return history, history
+
+block = gradio.Blocks(theme=gradio.themes.Monochrome())
+chatbot_llm = ChatbotAgent()
+chatbot_llm.create_user(user_id="test")
+
 
 if __name__ == "__main__":
-    demo.launch()
+    with block:
+        gradio.Markdown("""<h1><center>ChatBot  
+        ChatBot for suggesting Cost and video script</center></h1>""")
+        chatbot = gradio.Chatbot()
+        message = gradio.Textbox(placeholder="Enter Your Query Here")
+        state = gradio.State()
+        submit = gradio.Button("SEND")
+        submit.click(message_and_history,
+                    inputs=[message, state],
+                    outputs=[chatbot, state])
+    block.launch(debug = True)

chatbot_agent.py

@@ -1,17 +1,12 @@
 import os
 from openai import OpenAI
-from langchain.schema import Document
-from langchain_core.prompts import PromptTemplate
-from langchain_openai import OpenAIEmbeddings, ChatOpenAI
-from langchain.vectorstores import FAISS
-from langchain_core.runnables import RunnablePassthrough
-from langchain_core.output_parsers import StrOutputParser
-import pandas as pd
 from abc import ABC, abstractmethod
 from tools import *
+from dotenv import load_dotenv
 
 
-os.environ['OPENAI_API_KEY'] = "OPEN_API_KEY"
+load_dotenv()
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
 client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
 
 

requirements.txt

@@ -2,7 +2,11 @@ huggingface_hub==0.25.2
 autogluon
 scikit-learn
 seaborn
-langchain-community 
+langchain-community
+langchain-openai
+langchain_core
+langchain-google-vertexai
+langchain
 faiss-cpu
 openai
-langchain-openai
+gradio

tools.py

@@ -1,22 +1,26 @@
 import os
-from openai import OpenAI
 from langchain.schema import Document
 from langchain_core.prompts import PromptTemplate
 from langchain_openai import OpenAIEmbeddings, ChatOpenAI
-from langchain.vectorstores import FAISS
+from langchain_community.vectorstores import FAISS
 from langchain_core.runnables import RunnablePassthrough
 from langchain_core.output_parsers import StrOutputParser
+from autogluon.tabular import TabularPredictor
+import random
 import pandas as pd
+from dotenv import load_dotenv
 
+load_dotenv()
+os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY")
 # Function to convert a DataFrame row to a Document
 def row_to_document(row):
     content = (
-        f"Name of KOL: {row['KOL Name']} has {row['FOLLOWERS']} followers, "
+        f"Name of KOL: {row['kol_name']} has {row['FOLLOWERS']} followers, "
         f"received {row['LIKES']} likes, "
         f"average {row['Avg VIEWS from last 5 videos']} views from the last 5 videos, "
         f"and costs ${row['COST']} per collaboration.")
     metadata = {
-        'KOL Name': row['KOL Name'],
+        'KOL Name': row['kol_name'],
         'FOLLOWERS': row['FOLLOWERS'],
         'LIKES': row['LIKES'],
         'Avg VIEWS from last 5 videos': row['Avg VIEWS from last 5 videos'],
@@ -31,18 +35,29 @@ def call_rag_workflow(prompts:str = "") -> str:
     chain = ({"information": retriever, "prompt": RunnablePassthrough()} | prompt | model | StrOutputParser())
     response = chain.invoke(prompts)
     return f"respone from chatbot using RAG: {str(response)}"
-def inference_cost_model(information: str = "") -> str:
-    return 0
+def inference_cost_model(prompts: str = "") -> str:
+    model = TabularPredictor.load("AutogluonModels/ag-20241226_034850")
+    result = model.predict(prompts)
+    return f"respone from chatbot using cost prediction model: {str(result)}"
+def inference_view_model(prompts: str = "") -> str:
+    model = TabularPredictor.load("AutogluonModels/ag-20241227_060803")
+    result = model.predict(prompts)
+    return f"respone from chatbot using cost prediction model: {str(result)}"
+def inference_ranking_model(prompts: str = "") -> str:
+    return f"respone from chatbot using cost prediction model: {str(random.choice([1,2,3,4,5]))}"
 def get_tools():
-    tools = [call_rag_workflow]
+    tools = [call_rag_workflow, 
+             inference_cost_model, 
+             inference_view_model,
+             inference_ranking_model]
     tools = {func.__name__: func for func in tools}
     return tools
 
 
 data_lineup = pd.read_csv("data/data_lineup.csv")
+data_lineup.rename(columns = {"KOL Name" : "kol_name"}, inplace=True)
 documents = data_lineup.apply(row_to_document, axis=1).tolist()
 
-
 openai_tools = [
     {
         "type": "function",
@@ -56,17 +71,39 @@ openai_tools = [
                     to perform query to get knowdlege from vector store. Default: None"""},}, 
                 "required": ["prompts"]},
         },
-    },
-    # {
-    #     "type": "function",
-    #     "function": {
-    #         "name": "inference_cost_model",
-    #         "description": """this is a description""",
-    #         "parameters": {"type": "object", 
-    #             "properties": {
-    #                 "information": {"type": "", "description": """this is a description"""},}, 
-    #             "required": ["information"]},
-    #     },
-    # }
+    }
+    ,{
+        "type": "function",
+        "function": {
+            "name": "inference_cost_model",
+            "description": """this is a description""",
+            "parameters": {"type": "object", 
+                "properties": {
+                    "prompts": {"type": "string", "description": """this is a description"""},}, 
+                "required": ["prompts"]},
+        },
+    }
+    ,{
+        "type": "function",
+        "function": {
+            "name": "inference_view_model",
+            "description": """this is a description""",
+            "parameters": {"type": "object", 
+                "properties": {
+                    "prompts": {"type": "string", "description": """this is a description"""},}, 
+                "required": ["prompts"]},
+        },
+    }
+    ,{
+        "type": "function",
+        "function": {
+            "name": "inference_ranking_model",
+            "description": """this is a description""",
+            "parameters": {"type": "object", 
+                "properties": {
+                    "prompts": {"type": "string", "description": """this is a description"""},}, 
+                "required": ["prompts"]},
+        },
+    }
 ]
 local_tools = get_tools()