feature(#9): updated sendNotificaiton with its configuration.

Brain/src/common/assembler.py

@@ -5,7 +5,13 @@ from Brain.src.common.http_response_codes import responses
 from Brain.src.model.basic_model import BasicModel
 from Brain.src.model.contact_model import ContactModel
 from Brain.src.model.message_model import MessageModel
-from Brain.src.model.requests.request_model import ChatRising, SendSMS, TrainContacts
+from Brain.src.model.req_model import ReqModel
+from Brain.src.model.requests.request_model import (
+    ChatRising,
+    SendSMS,
+    TrainContacts,
+    BasicReq,
+)
 from Brain.src.model.sms_model import SMSModel
 
 
@@ -58,3 +64,8 @@ class Assembler:
 
     def to_result_format(self, program: str, content: str) -> Any:
         return {"program": program, "content": content}
+
+    """mapping basic req"""
+
+    def to_req_model(self, basic_req: BasicReq) -> ReqModel:
+        return ReqModel(basic_req.to_json())

Brain/src/common/utils.py

@@ -5,6 +5,7 @@ import re
 from firebase_admin import credentials
 
 # env variables
+DEFAULT_HOST_NAME = "test3-83ffc.appspot.com"
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 PINECONE_KEY = os.getenv("PINECONE_KEY")
 PINECONE_ENV = os.getenv("PINECONE_ENV")
@@ -17,7 +18,7 @@ API_URL = "http://localhost:5000/file/swagger.json"
 
 # firebase
 FIREBASE_STORAGE_ROOT = "images/"
-FIREBASE_STORAGE_BUCKET = "test3-83ffc.appspot.com"
+FIREBASE_STORAGE_BUCKET = DEFAULT_HOST_NAME
 
 # pinecone
 PINECONE_NAMESPACE = "risinglangchain-namespace"

Brain/src/model/req_model.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from Brain.src.common.utils import DEFAULT_HOST_NAME
+
+
+class ReqModel:
+    class Settings:
+        def __init__(self):
+            self.temperature: float = 0.6
+
+    host_name: str
+    openai_key: str
+    pinecone_key: str
+    pinecone_env: str
+    firebase_key: str
+    token: str = ""
+    uuid: str = ""
+    settings: Settings
+
+    def __init__(self, data: dict):
+        self.host_name = (
+            DEFAULT_HOST_NAME if data["host_name"] == "" else data["host_name"]
+        )
+        self.openai_key = (
+            DEFAULT_HOST_NAME if data["openai_key"] == "" else data["openai_key"]
+        )
+        self.pinecone_key = (
+            DEFAULT_HOST_NAME if data["pinecone_key"] == "" else data["pinecone_key"]
+        )
+        self.pinecone_env = (
+            DEFAULT_HOST_NAME if data["pinecone_env"] == "" else data["pinecone_env"]
+        )
+        self.firebase_key = (
+            DEFAULT_HOST_NAME if data["firebase_key"] == "" else data["firebase_key"]
+        )
+        self.token = data["token"]
+        self.uuid = data["uuid"]
+        self.settings = self.Settings()
+        self.settings.temperature = data["settings"]["temperature"]
+
+    def to_json(self):
+        return {
+            "host_name": self.host_name,
+            "openai_key": self.openai_key,
+            "pinecone_key": self.pinecone_key,
+            "pinecone_env": self.pinecone_env,
+            "firebase_key": self.firebase_key,
+            "settings": {"temperature": self.settings.temperature},
+            "token": self.token,
+            "uuid": self.uuid,
+        }

Brain/src/model/requests/request_model.py

@@ -4,6 +4,14 @@ from pydantic import BaseModel
 from fastapi import Depends, Request, HTTPException
 from user_agents import parse
 
+from Brain.src.common.utils import (
+    DEFAULT_HOST_NAME,
+    OPENAI_API_KEY,
+    PINECONE_KEY,
+    FIREBASE_ENV,
+    PINECONE_ENV,
+)
+
 """user-agent management"""
 
 
@@ -50,10 +58,46 @@ def get_client_info(request: Request):
     return parse_user_agent(user_agent)
 
 
+"""
+{
+    "host_name": string,
+    "openai_key": string, 
+    "pinecone_key": string, 
+    "pinecone_env": string,
+    "firebase_key": string,
+    "settings": {
+            "temperature": float
+        }, 
+    "token": string, 
+    "uuid": string, 
+}
+"""
+
+
 class BasicReq(BaseModel):
-    token: str
-    uuid: str
-    model: str = "gpt-3.5-turbo"
+    class Settings(BaseModel):
+        temperature: float = 0.6
+
+    host_name: str
+    openai_key: str
+    pinecone_key: str
+    pinecone_env: str
+    firebase_key: str
+    token: str = ""
+    uuid: str = ""
+    settings: Settings
+
+    def to_json(self):
+        return {
+            "host_name": self.host_name,
+            "openai_key": self.openai_key,
+            "pinecone_key": self.pinecone_key,
+            "pinecone_env": self.pinecone_env,
+            "firebase_key": self.firebase_key,
+            "settings": {"temperature": self.settings.temperature},
+            "token": self.token,
+            "uuid": self.uuid,
+        }
 
 
 """endpoint: /sendNotification"""

Brain/src/rising_plugin/guardrails-config/actions/actions.py

@@ -27,7 +27,10 @@ from Brain.src.common.utils import (
     OPENAI_API_KEY,
     COMMAND_SMS_INDEXS,
     COMMAND_BROWSER_OPEN,
+    DEFAULT_GPT_MODEL,
 )
+from Brain.src.model.req_model import ReqModel
+from Brain.src.model.requests.request_model import BasicReq
 from Brain.src.rising_plugin.image_embedding import (
     query_image_text,
 )
@@ -42,6 +45,7 @@ from Brain.src.rising_plugin.llm.llms import (
     GPT_4_32K,
     GPT_4,
     FALCON_7B,
+    GPT_LLM_MODELS,
 )
 
 """
@@ -51,12 +55,27 @@ query is json string with below format
     "model": string,
     "uuid": string,
     "image_search": bool,
+    "setting": {
+        "host_name": string,
+        "openai_key": string, 
+        "pinecone_key": string, 
+        "pinecone_env": string,
+        "firebase_key": string,
+        "firebase_env": string 
+        "settings": {
+                "temperature": float
+            }, 
+        "token": string, 
+        "uuid": string, 
+    }
 }
 """
 
 
 @action()
 async def general_question(query):
+    """init falcon model"""
+    falcon_llm = FalconLLM()
     """step 0: convert string to json"""
     try:
         json_query = json.loads(query)
@@ -67,13 +86,14 @@ async def general_question(query):
     model = json_query["model"]
     uuid = json_query["uuid"]
     image_search = json_query["image_search"]
+    setting = ReqModel(json_query["setting"])
 
     """step 1: handle with gpt-4"""
     file_path = os.path.dirname(os.path.abspath(__file__))
 
     with open(f"{file_path}/phone.json", "r") as infile:
         data = json.load(infile)
-    embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
+    embeddings = OpenAIEmbeddings(openai_api_key=setting.openai_key)
 
     query_result = embeddings.embed_query(query)
     doc_list = utils.maximal_marginal_relevance(np.array(query_result), data, k=1)
@@ -89,15 +109,15 @@ async def general_question(query):
             )
         )
 
-    chain_data = get_llm_chain(model=model).run(input_documents=docs, question=query)
-    # test
-    # if model == GPT_3_5_TURBO or model == GPT_4 or model == GPT_4_32K:
-    #     gpt_llm = GptLLM(model=model)
-    #     chain_data = gpt_llm.get_chain().run(input_documents=docs, question=query)
-    # elif model == FALCON_7B:
-    #     falcon_llm = FalconLLM()
-    #     chain_data = falcon_llm.get_chain().run(question=query)
-    falcon_llm = FalconLLM()
+    """ 1. calling gpt model to categorize for all message"""
+    if model in GPT_LLM_MODELS:
+        chain_data = get_llm_chain(model=model, setting=setting).run(
+            input_documents=docs, question=query
+        )
+    else:
+        chain_data = get_llm_chain(model=DEFAULT_GPT_MODEL, setting=setting).run(
+            input_documents=docs, question=query
+        )
     try:
         result = json.loads(chain_data)
         # check image query with only its text
@@ -106,12 +126,10 @@ async def general_question(query):
                 result["content"] = {
                     "image_name": query_image_text(result["content"], "", uuid)
                 }
-
-            # else:
-            #     return result
-        """check program is message to handle it with falcon llm"""
+        """ 2. check program is message to handle it with falcon llm """
         if result["program"] == "message":
-            result["content"] = falcon_llm.query(question=query)
+            if model == FALCON_7B:
+                result["content"] = falcon_llm.query(question=query)
         return str(result)
     except ValueError as e:
         # Check sms and browser query
@@ -119,4 +137,5 @@ async def general_question(query):
             return str({"program": "sms", "content": chain_data})
         elif doc_list[0] in COMMAND_BROWSER_OPEN:
             return str({"program": "browser", "content": "https://google.com"})
+
         return str({"program": "message", "content": falcon_llm.query(question=query)})

Brain/src/rising_plugin/llm/gpt_llm.py

@@ -9,12 +9,13 @@ from Brain.src.common.utils import (
 
 
 class GptLLM:
-    def __init__(self, model: str = "gpt-3.5-turbo", temperature: float = 0.6):
+    def __init__(self, openai_key: str, model: str = "gpt-4", temperature: float = 0.6):
+        self.key = openai_key
         self.llm = self.init_llm(model=model, temperature=temperature)
 
-    def init_llm(self, model: str = "gpt-3.5-turbo", temperature: float = 0.6) -> Any:
+    def init_llm(self, model: str = "gpt-4", temperature: float = 0.6) -> Any:
         self.llm = ChatOpenAI(
-            model_name=model, temperature=temperature, openai_api_key=OPENAI_API_KEY
+            model_name=model, temperature=temperature, openai_api_key=self.key
         )
         return self.llm
 

Brain/src/rising_plugin/llm/llms.py

@@ -2,6 +2,8 @@
 from typing import Any
 
 from Brain.src.common.brain_exception import BrainException
+from Brain.src.model.req_model import ReqModel
+from Brain.src.model.requests.request_model import BasicReq
 from Brain.src.rising_plugin.llm.falcon_llm import FalconLLM
 from Brain.src.rising_plugin.llm.gpt_llm import GptLLM
 
@@ -12,6 +14,7 @@ FALCON_7B = "falcon-7b"
 
 """list of available model we offer you"""
 LLM_MODELS = [GPT_3_5_TURBO, GPT_4, GPT_4_32K, FALCON_7B]
+GPT_LLM_MODELS = [GPT_3_5_TURBO, GPT_4, GPT_4_32K]
 
 
 """exception message"""
@@ -35,23 +38,30 @@ datatype: LLmChain
 
 
 def get_llm_chain(
-    model: str, temperature: float = 0.6, max_new_tokens: int = 2000
+    setting: ReqModel, model: str, temperature: float = 0.6, max_new_tokens: int = 2000
 ) -> Any:
     if not validate_model(model):
         raise BrainException(EXCEPTION_MSG)
     """check model"""
-    llm = get_llm(model=model, temperature=temperature, max_new_tokens=max_new_tokens)
+    llm = get_llm(
+        model=model,
+        temperature=temperature,
+        max_new_tokens=max_new_tokens,
+        setting=setting,
+    )
 
     return llm.get_chain()
 
 
-def get_llm(model: str, temperature: float = 0.6, max_new_tokens: int = 2000) -> Any:
+def get_llm(
+    setting: ReqModel, model: str, temperature: float = 0.6, max_new_tokens: int = 2000
+) -> Any:
     if not validate_model(model):
         raise BrainException(EXCEPTION_MSG)
     """check model"""
-    llm = GptLLM()
+    llm = GptLLM(openai_key=setting.openai_key)
     if model == GPT_3_5_TURBO or model == GPT_4 or model == GPT_4_32K:
-        llm = GptLLM(model=model)
+        llm = GptLLM(model=model, openai_key=setting.openai_key)
     elif model == FALCON_7B:
         llm = FalconLLM(temperature=temperature, max_new_tokens=max_new_tokens)
     return llm

Brain/src/rising_plugin/risingplugin.py

@@ -25,6 +25,8 @@ from .image_embedding import (
     query_image_text,
     get_prompt_image_with_message,
 )
+from ..model.req_model import ReqModel
+from ..model.requests.request_model import BasicReq
 
 # Give the path to the folder containing the rails
 file_path = os.path.dirname(os.path.abspath(__file__))
@@ -41,7 +43,12 @@ def getChunks(query: str):
 
 
 def processLargeText(
-    app: any, chunks: any, model: str, uuid: str = "", image_search: bool = True
+    setting: ReqModel,
+    app: any,
+    chunks: any,
+    model: str,
+    uuid: str = "",
+    image_search: bool = True,
 ):
     if len(chunks) == 1:
         message = app.generate(
@@ -49,6 +56,7 @@ def processLargeText(
                 {
                     "role": "user",
                     "content": rails_input_with_args(
+                        setting=setting,
                         query=chunks[0],
                         model=model,
                         uuid=uuid,
@@ -89,6 +97,7 @@ def processLargeText(
                         {
                             "role": "user",
                             "content": rails_input_with_args(
+                                setting=setting,
                                 query=chunk_query,
                                 model=model,
                                 uuid=uuid,
@@ -116,6 +125,7 @@ def processLargeText(
                         {
                             "role": "user",
                             "content": rails_input_with_args(
+                                setting=setting,
                                 query=last_query,
                                 model=model,
                                 uuid=uuid,
@@ -130,19 +140,26 @@ def processLargeText(
 
 
 def getCompletion(
-    query,
-    model=DEFAULT_GPT_MODEL,
-    uuid="",
-    image_search=True,
+    query: str,
+    setting: ReqModel,
+    model: str = DEFAULT_GPT_MODEL,
+    uuid: str = "",
+    image_search: bool = True,
 ):
-    llm = get_llm(model=DEFAULT_GPT_MODEL).get_llm()
+    llm = get_llm(model=DEFAULT_GPT_MODEL, setting=setting).get_llm()
+
     # Break input text into chunks
     chunks = getChunks(query)
 
     app = LLMRails(config, llm)
 
     return processLargeText(
-        app=app, chunks=chunks, model=model, uuid=uuid, image_search=image_search
+        setting=setting,
+        app=app,
+        chunks=chunks,
+        model=model,
+        uuid=uuid,
+        image_search=image_search,
     )
 
 
@@ -156,10 +173,12 @@ def getCompletionOnly(
     return chain_data
 
 
-def query_image_ask(image_content, message, uuid):
+def query_image_ask(image_content, message, uuid, setting: BasicReq):
     prompt_template = get_prompt_image_with_message(image_content, message)
     try:
-        data = getCompletion(query=prompt_template, uuid=uuid, image_search=False)
+        data = getCompletion(
+            query=prompt_template, uuid=uuid, image_search=False, setting=setting
+        )
         # chain_data = json.loads(data.replace("'", '"'))
         # chain_data = json.loads(data)
         if data["program"] == "image":
@@ -214,15 +233,15 @@ response:
 
 
 # Define a content filter function
-def filter_guardrails(model: any, query: str):
-    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=OPENAI_API_KEY)
+def filter_guardrails(setting: BasicReq, model: any, query: str):
+    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=setting.openai_key)
     app = LLMRails(config, llm)
 
     # split query with chunks
     chunks = getChunks(query)
 
     # get message from guardrails
-    message = processLargeText(app=app, chunks=chunks, model=model)
+    message = processLargeText(app=app, chunks=chunks, model=model, setting=setting)
 
     if (
         message
@@ -240,13 +259,16 @@ compose json_string for rails input with its arguments
 """
 
 
-def rails_input_with_args(query: str, model: str, uuid: str, image_search: bool) -> str:
+def rails_input_with_args(
+    setting: ReqModel, query: str, model: str, uuid: str, image_search: bool
+) -> str:
     # convert json with params for rails.
     json_query_with_params = {
         "query": query,
         "model": model,
         "uuid": uuid,
         "image_search": image_search,
+        "setting": setting.to_json(),
     }
     return json.dumps(json_query_with_params)
 

Brain/src/router/api.py

@@ -68,7 +68,9 @@ def construct_blueprint_api() -> APIRouter:
         if client_info.is_browser():
             query = f"{query} in a web browser"
 
-        result = getCompletion(query=query, uuid=uuid)
+        result = getCompletion(
+            query=query, uuid=uuid, setting=assembler.to_req_model(data)
+        )
 
         # check contact querying
         try:
@@ -144,7 +146,9 @@ def construct_blueprint_api() -> APIRouter:
         image_response = {}
         try:
             # check about asking image description with trained data
-            if query_image_ask(image_content, message, uuid):
+            if query_image_ask(
+                image_content=image_content, message=message, uuid=uuid, setting=data
+            ):
                 image_response["image_desc"] = image_content
             else:
                 relatedness_data = query_image_text(image_content, message, uuid)