Merge pull request #84 from ttt246/feature/llm_interface_9

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/brain_exception.py

@@ -7,10 +7,11 @@ from Brain.src.common.http_response_codes import responses
 class BrainException(Exception):
     JSON_PARSING_ISSUE_MSG = "Exception occurred in json paring."
 
-    def __init__(self, message: str = "Exception occurred in brain"):
+    def __init__(self, message: str = "Exception occurred in brain", code: int = 506):
         self.message = message
+        self.code = code
         super().__init__(self.message)
 
     def get_response_exp(self) -> Any:
-        responses[506] = ("Brain Exception", self.message)
-        return {"message": responses[506], "result": "", "status_code": 506}
+        responses[self.code] = ("Brain Exception", self.message)
+        return {"message": responses[self.code], "result": "", "status_code": self.code}

Brain/src/common/http_response_codes.py

@@ -49,4 +49,6 @@ responses = {
     504: ("Gateway Timeout", "The gateway server did not receive a timely response"),
     505: ("HTTP Version Not Supported", "Cannot fulfill request."),
     506: ("Brain Exception"),
+    507: ("Firebase Connection Error", "Your key is not correct."),
+    508: ("Pinecone Connection Error", "Your key or env is not correct."),
 }

Brain/src/common/utils.py

@@ -2,7 +2,6 @@ import json
 import os
 import re
 
-from firebase_admin import credentials
 
 # env variables
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
@@ -40,17 +39,6 @@ AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
 HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
 
 
-def get_firebase_cred():
-    if os.path.exists("Brain/firebase_cred.json"):
-        file = open("Brain/firebase_cred.json")
-        cred = json.load(file)
-        file.close()
-        return credentials.Certificate(cred)
-    else:
-        cred = json.loads(FIREBASE_ENV)
-        return credentials.Certificate(cred)
-
-
 class ProgramType:
     BROWSER = "browser"
     ALERT = "alert"

Brain/src/firebase/cloudmessage.py

@@ -3,72 +3,84 @@ import sys
 import json
 
 import traceback
-from firebase_admin import messaging, firestore
+from typing import Any
 
-db = firestore.client()
+import firebase_admin
+from firebase_admin import messaging, firestore
 
 
-def get_tokens():
-    users_ref = db.collection("users")
-    docs = users_ref.stream()
-    registeration_tokens = []
-    for doc in docs:
-        registeration_tokens.append(doc.to_dict()["token"])
-    return registeration_tokens
+class CloudMessage:
+    def __init__(self, firebase_app: firebase_admin.App):
+        self.firebase_app = firebase_app
+        self.db = firestore.client(app=firebase_app)
 
+    def get_tokens(self):
+        users_ref = self.db.collection("users")
+        docs = users_ref.stream()
+        registeration_tokens = []
+        for doc in docs:
+            registeration_tokens.append(doc.to_dict()["token"])
+        return registeration_tokens
 
-def exception_detail(e):
-    error_class = e.__class__.__name__
-    detail = e.args[0]
-    cl, exc, tb = sys.exc_info()
-    lastCallStack = traceback.extract_tb(tb)[-1]
-    fileName = lastCallStack[0]
-    lineNum = lastCallStack[1]
-    funcName = lastCallStack[2]
-    errMsg = 'File "{}", line {}, in {}: [{}] {}'.format(
-        fileName, lineNum, funcName, error_class, detail
-    )
-    return errMsg
+    def exception_detail(self, e):
+        error_class = e.__class__.__name__
+        detail = e.args[0]
+        cl, exc, tb = sys.exc_info()
+        lastCallStack = traceback.extract_tb(tb)[-1]
+        fileName = lastCallStack[0]
+        lineNum = lastCallStack[1]
+        funcName = lastCallStack[2]
+        errMsg = 'File "{}", line {}, in {}: [{}] {}'.format(
+            fileName, lineNum, funcName, error_class, detail
+        )
+        return errMsg
 
+    def send_message(self, notification, token_list):
+        if token_list == []:
+            return False, "token_list empty"
+        if notification.get("title") not in [None, ""]:
+            notify = messaging.Notification(
+                title=notification.get("title"),
+                body=notification.get("content", ""),
+            )
+            android_notify = messaging.AndroidNotification(
+                title=notification.get("title"),
+                body=notification.get("content", ""),
+                default_sound=True,
+            )
+        else:
+            notify = messaging.Notification(body=notification.get("content", ""))
+            android_notify = messaging.AndroidNotification(
+                body=notification.get("content", ""), default_sound=True
+            )
 
-def send_message(notification, token_list):
-    if token_list == []:
-        return False, "token_list empty"
-    if notification.get("title") not in [None, ""]:
-        notify = messaging.Notification(
-            title=notification.get("title"), body=notification.get("content", "")
+        multi_msg = messaging.MulticastMessage(
+            notification=notify,
+            tokens=token_list,
+            data={}
+            if "route" not in notification
+            else {"direct": notification["route"]},
+            android=messaging.AndroidConfig(
+                notification=android_notify, priority="high"
+            ),
+            apns=messaging.APNSConfig(
+                payload=messaging.APNSPayload(
+                    messaging.Aps(sound=messaging.CriticalSound("default", volume=1.0))
+                )
+            ),
         )
-        android_notify = messaging.AndroidNotification(
-            title=notification.get("title"),
-            body=notification.get("content", ""),
-            default_sound=True,
+        response = messaging.send_multicast(
+            multi_msg,
+            app=self.firebase_app,
         )
-    else:
-        notify = messaging.Notification(body=notification.get("content", ""))
-        android_notify = messaging.AndroidNotification(
-            body=notification.get("content", ""), default_sound=True
+        failed_tokens = []
+        if response.failure_count > 0:
+            responses = response.responses
+            for idx, resp in enumerate(responses):
+                if not resp.success:
+                    # The order of responses corresponds to the order of the registration tokens.
+                    failed_tokens.append(token_list[idx])
+            print("List of tokens that caused failures: {0}".format(failed_tokens))
+        return True, "send to {} devices, with {} successed, with {} failed.".format(
+            len(token_list), response.success_count, response.failure_count
         )
-
-    multi_msg = messaging.MulticastMessage(
-        notification=notify,
-        tokens=token_list,
-        data={} if "route" not in notification else {"direct": notification["route"]},
-        android=messaging.AndroidConfig(notification=android_notify, priority="high"),
-        apns=messaging.APNSConfig(
-            payload=messaging.APNSPayload(
-                messaging.Aps(sound=messaging.CriticalSound("default", volume=1.0))
-            )
-        ),
-    )
-    response = messaging.send_multicast(multi_msg)
-    failed_tokens = []
-    if response.failure_count > 0:
-        responses = response.responses
-        for idx, resp in enumerate(responses):
-            if not resp.success:
-                # The order of responses corresponds to the order of the registration tokens.
-                failed_tokens.append(token_list[idx])
-        print("List of tokens that caused failures: {0}".format(failed_tokens))
-    return True, "send to {} devices, with {} successed, with {} failed.".format(
-        len(token_list), response.success_count, response.failure_count
-    )

Brain/src/firebase/firebase.py

@@ -1,8 +1,60 @@
+import json
+import os
+from typing import Any
+
 import firebase_admin
-from Brain.src.common.utils import get_firebase_cred, FIREBASE_STORAGE_BUCKET
+from firebase_admin import credentials
+
+from Brain.src.common.assembler import Assembler
+from Brain.src.common.brain_exception import BrainException
+from Brain.src.common.http_response_codes import responses
+from Brain.src.common.utils import FIREBASE_STORAGE_BUCKET
+from Brain.src.logs import logger
+from Brain.src.model.req_model import ReqModel
+from Brain.src.model.requests.request_model import BasicReq
 
 
-def initialize_app():
-    firebase_admin.initialize_app(
-        get_firebase_cred(), {"storageBucket": FIREBASE_STORAGE_BUCKET}
+def initialize_app(setting: ReqModel) -> firebase_admin.App:
+    app_name = get_firebase_admin_name(setting.uuid)
+    # Check if the app is already initialized
+    try:
+        app = firebase_admin.get_app(app_name)
+        if app is not None:
+            # Delete the existing app
+            firebase_admin.delete_app(app)
+    except Exception as ex:
+        logger.warn(
+            title="firebase init",
+            message=f"this app name: {app_name} does not exist",
+        )
+    return firebase_admin.initialize_app(
+        get_firebase_cred(setting),
+        {"storageBucket": FIREBASE_STORAGE_BUCKET},
+        name=app_name,
     )
+
+
+def get_firebase_admin_name(uuid: str = ""):
+    return f"firebase_admin_{uuid}"
+
+
+def firebase_admin_with_setting(data: BasicReq):
+    # firebase admin init
+    assembler = Assembler()
+    setting = assembler.to_req_model(data)
+    try:
+        firebase_app = initialize_app(setting)
+    except Exception as ex:
+        raise BrainException(code=507, message=responses[507])
+    return setting, firebase_app
+
+
+def get_firebase_cred(setting: ReqModel):
+    if os.path.exists("Brain/firebase_cred.json"):
+        file = open("Brain/firebase_cred.json")
+        cred = json.load(file)
+        file.close()
+        return credentials.Certificate(cred)
+    else:
+        cred = json.loads(setting.firebase_key)
+        return credentials.Certificate(cred)

Brain/src/model/req_model.py

@@ -0,0 +1,51 @@
+from typing import Any
+
+from Brain.src.common.utils import (
+    OPENAI_API_KEY,
+    PINECONE_KEY,
+    PINECONE_ENV,
+    FIREBASE_ENV,
+)
+
+
+class ReqModel:
+    class Settings:
+        def __init__(self):
+            self.temperature: float = 0.6
+
+    openai_key: str
+    pinecone_key: str
+    pinecone_env: str
+    firebase_key: str
+    token: str = ""
+    uuid: str = ""
+    settings: Settings
+
+    def __init__(self, data: dict):
+        self.openai_key = (
+            OPENAI_API_KEY if data["openai_key"] == "" else data["openai_key"]
+        )
+        self.pinecone_key = (
+            PINECONE_KEY if data["pinecone_key"] == "" else data["pinecone_key"]
+        )
+        self.pinecone_env = (
+            PINECONE_ENV if data["pinecone_env"] == "" else data["pinecone_env"]
+        )
+        self.firebase_key = (
+            FIREBASE_ENV 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 {
+            "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

@@ -50,10 +50,44 @@ 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
+
+    openai_key: str
+    pinecone_key: str
+    pinecone_env: str
+    firebase_key: str
+    token: str = ""
+    uuid: str = ""
+    settings: Settings
+
+    def to_json(self):
+        return {
+            "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"""
@@ -102,7 +136,6 @@ class ChatRising(BasicReq):
 
     history: list[Format]
     user_input: str
-    model: str
 
 
 """endpoint: /send_sms"""

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

@@ -13,7 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import os
 import json
+import numpy as np
 
 from Brain.src.service.train_service import TrainService
 from langchain.docstore.document import Document
@@ -23,7 +25,10 @@ from Brain.src.common.utils import (
     COMMAND_SMS_INDEXES,
     COMMAND_BROWSER_OPEN,
     PINECONE_INDEX_NAME,
+    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,
 )
@@ -39,6 +44,7 @@ from Brain.src.rising_plugin.llm.llms import (
     GPT_4_32K,
     GPT_4,
     FALCON_7B,
+    GPT_LLM_MODELS,
 )
 
 from Brain.src.rising_plugin.pinecone_engine import (
@@ -46,68 +52,70 @@ from Brain.src.rising_plugin.pinecone_engine import (
     init_pinecone,
 )
 
+"""
+query is json string with below format
+{
+    "query": string,
+    "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):
-    """step 0: convert string to json"""
-    index = init_pinecone(PINECONE_INDEX_NAME)
-    train_service = TrainService()
+    """init falcon model"""
+    falcon_llm = FalconLLM()
+    docs = []
+
+    """step 0-->: parsing parms from the json query"""
     try:
         json_query = json.loads(query)
     except Exception as ex:
         raise BrainException(BrainException.JSON_PARSING_ISSUE_MSG)
-    """step 0-->: parsing params from the json query"""
     query = json_query["query"]
-    model = json_query["model"]
-    uuid = json_query["uuid"]
     image_search = json_query["image_search"]
+    page_content = json_query["page_content"]
+    document_id = json_query["document_id"]
+    setting = ReqModel(json_query["setting"])
 
-    """step 1: handle with gpt-4"""
-
-    query_result = get_embed(query)
-    relatedness_data = index.query(
-        vector=query_result,
-        top_k=1,
-        include_values=False,
-        namespace=train_service.get_pinecone_index_train_namespace(),
+    docs.append(Document(page_content=page_content, metadata=""))
+    """ 1. calling gpt model to categorize for all message"""
+    chain_data = get_llm_chain(model=DEFAULT_GPT_MODEL, setting=setting).run(
+        input_documents=docs, question=query
     )
-    documentId = ""
-    if len(relatedness_data["matches"]) > 0:
-        documentId = relatedness_data["matches"][0]["id"]
-    else:
-        return None
-    docs = []
-    document = train_service.read_one_document(documentId)
-    docs.append(Document(page_content=document["page_content"], metadata=""))
-
-    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()
     try:
         result = json.loads(chain_data)
         # check image query with only its text
         if result["program"] == "image":
             if image_search:
                 result["content"] = {
-                    "image_name": query_image_text(result["content"], "", uuid)
+                    "image_name": query_image_text(result["content"], "", setting)
                 }
-
-            # 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":
+            """FALCON_7B:"""
             result["content"] = falcon_llm.query(question=query)
         return str(result)
     except ValueError as e:
         # Check sms and browser query
-        if documentId in COMMAND_SMS_INDEXES:
+        if document_id in COMMAND_SMS_INDEXES:
             return str({"program": "sms", "content": chain_data})
-        elif documentId in COMMAND_BROWSER_OPEN:
+        elif document_id 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/image_embedding.py

@@ -9,6 +9,7 @@ from .pinecone_engine import (
 )
 from ..model.basic_model import DataStatus
 from ..model.image_model import ImageModel
+from ..model.req_model import ReqModel
 
 
 def get_embeddings():
@@ -16,7 +17,7 @@ def get_embeddings():
 
 
 # def embed_image_text(image_text: str, image_name: str, uuid: str) -> str:
-def embed_image_text(image: ImageModel) -> str:
+def embed_image_text(image: ImageModel, setting: ReqModel) -> str:
     prompt_template = f"""
         This is the text about the image.
         ###
@@ -24,7 +25,7 @@ def embed_image_text(image: ImageModel) -> str:
         """
 
     embed_image = get_embeddings().embed_query(prompt_template)
-    index = init_pinecone(PINECONE_INDEX_NAME)
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
 
     """create | update | delete in pinecone"""
     pinecone_namespace = get_pinecone_index_namespace(image.uuid)
@@ -46,16 +47,16 @@ def embed_image_text(image: ImageModel) -> str:
     return "success to embed image text"
 
 
-def query_image_text(image_content, message, uuid):
+def query_image_text(image_content, message, setting: ReqModel):
     embed_image = get_embeddings().embed_query(
         get_prompt_image_with_message(image_content, message)
     )
-    index = init_pinecone(PINECONE_INDEX_NAME)
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
     relatedness_data = index.query(
         vector=embed_image,
         top_k=3,
         include_values=False,
-        namespace=get_pinecone_index_namespace(uuid),
+        namespace=get_pinecone_index_namespace(setting.uuid),
     )
     if len(relatedness_data["matches"]) > 0:
         return relatedness_data["matches"][0]["id"]

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/pinecone_engine.py

@@ -1,12 +1,14 @@
 # initialize pinecone
 import pinecone
 from typing import Any
+
+from ..common.brain_exception import BrainException
+from ..common.http_response_codes import responses
 from ..common.utils import (
-    PINECONE_KEY,
-    PINECONE_ENV,
     PINECONE_INDEX_NAME,
     PINECONE_NAMESPACE,
 )
+from ..model.req_model import ReqModel
 
 DIMENSION = 1536
 METRIC = "cosine"
@@ -14,22 +16,27 @@ POD_TYPE = "p1.x1"
 
 
 # get the existing index in pinecone or create a new one
-def init_pinecone(index_name, flag=True):
-    pinecone.init(api_key=PINECONE_KEY, environment=PINECONE_ENV)
-    if flag:
-        return pinecone.Index(index_name)
-    else:
-        # create a new index in pinecone
-        return pinecone.create_index(
-            index_name, dimension=DIMENSION, metric=METRIC, pod_type=POD_TYPE
-        )
+def init_pinecone(index_name, setting: ReqModel, flag=True):
+    try:
+        pinecone.init(api_key=setting.pinecone_key, environment=setting.pinecone_env)
+        if flag:
+            return pinecone.Index(index_name)
+        else:
+            # create a new index in pinecone
+            return pinecone.create_index(
+                index_name, dimension=DIMENSION, metric=METRIC, pod_type=POD_TYPE
+            )
+    except Exception as ex:
+        raise BrainException(code=508, message=responses[508])
 
 
 """add item in pinecone"""
 
 
-def add_pinecone(namespace: str, key: str, value: list[float]) -> Any:
-    index = init_pinecone(PINECONE_INDEX_NAME)
+def add_pinecone(
+    namespace: str, key: str, setting: ReqModel, value: list[float]
+) -> Any:
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
 
     upsert_response = index.upsert(
         vectors=[{"id": key, "values": value}],
@@ -41,8 +48,10 @@ def add_pinecone(namespace: str, key: str, value: list[float]) -> Any:
 """update item in pinecone"""
 
 
-def update_pinecone(namespace: str, key: str, value: list[float]) -> Any:
-    index = init_pinecone(PINECONE_INDEX_NAME)
+def update_pinecone(
+    setting: ReqModel, namespace: str, key: str, value: list[float]
+) -> Any:
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
 
     upsert_response = index.update(
         id=key,
@@ -55,8 +64,8 @@ def update_pinecone(namespace: str, key: str, value: list[float]) -> Any:
 """delete item in pinecone"""
 
 
-def delete_pinecone(namespace: str, key: str) -> Any:
-    index = init_pinecone(PINECONE_INDEX_NAME)
+def delete_pinecone(setting: ReqModel, namespace: str, key: str) -> Any:
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
     delete_response = index.delete(ids=[key], namespace=namespace)
     return delete_response
 
@@ -64,8 +73,8 @@ def delete_pinecone(namespace: str, key: str) -> Any:
 """delete all item in the namespace"""
 
 
-def delete_all_pinecone(namespace: str) -> Any:
-    index = init_pinecone(PINECONE_INDEX_NAME)
+def delete_all_pinecone(setting: ReqModel, namespace: str) -> Any:
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
     delete_response = index.delete(delete_all=True, namespace=namespace)
     return delete_response
 

Brain/src/rising_plugin/risingplugin.py

@@ -1,12 +1,15 @@
 import os
 import json
 import datetime
+
+import firebase_admin
 import openai
 import replicate
 import textwrap
 
 from typing import Any
 
+from langchain import LLMChain
 from langchain.chains.question_answering import load_qa_chain
 from nemoguardrails.rails import LLMRails, RailsConfig
 
@@ -14,17 +17,25 @@ from langchain.chat_models import ChatOpenAI
 
 from firebase_admin import storage
 
+from .csv_embed import get_embed
 from .llm.llms import get_llm, GPT_4, FALCON_7B
+from .pinecone_engine import init_pinecone
+from ..common.brain_exception import BrainException
+from ..common.http_response_codes import responses
 from ..common.utils import (
     OPENAI_API_KEY,
     FIREBASE_STORAGE_ROOT,
     DEFAULT_GPT_MODEL,
     parseJsonFromCompletion,
+    PINECONE_INDEX_NAME,
 )
 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
+from ..service.train_service import TrainService
 
 # Give the path to the folder containing the rails
 file_path = os.path.dirname(os.path.abspath(__file__))
@@ -40,22 +51,67 @@ def getChunks(query: str):
     )
 
 
+def llm_rails(
+    setting: ReqModel,
+    rails_app: any,
+    firebase_app: firebase_admin.App,
+    query: str,
+    image_search: bool = True,
+) -> Any:
+    """step 0: convert string to json"""
+    index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=setting)
+    train_service = TrainService(firebase_app=firebase_app, setting=setting)
+
+    """step 1: handle with gpt-4"""
+
+    query_result = get_embed(query)
+    try:
+        relatedness_data = index.query(
+            vector=query_result,
+            top_k=1,
+            include_values=False,
+            namespace=train_service.get_pinecone_index_train_namespace(),
+        )
+    except Exception as ex:
+        raise BrainException(code=508, message=responses[508])
+    if len(relatedness_data["matches"]) == 0:
+        return str({"program": "message", "content": ""})
+    document_id = relatedness_data["matches"][0]["id"]
+
+    document = train_service.read_one_document(document_id)
+    page_content = document["page_content"]
+
+    message = rails_app.generate(
+        messages=[
+            {
+                "role": "user",
+                "content": rails_input_with_args(
+                    setting=setting,
+                    query=query,
+                    image_search=image_search,
+                    page_content=page_content,
+                    document_id=document_id,
+                ),
+            }
+        ]
+    )
+    return message
+
+
 def processLargeText(
-    app: any, chunks: any, model: str, uuid: str = "", image_search: bool = True
+    setting: ReqModel,
+    app: any,
+    chunks: any,
+    firebase_app: firebase_admin.App,
+    image_search: bool = True,
 ):
     if len(chunks) == 1:
-        message = app.generate(
-            messages=[
-                {
-                    "role": "user",
-                    "content": rails_input_with_args(
-                        query=chunks[0],
-                        model=model,
-                        uuid=uuid,
-                        image_search=image_search,
-                    ),
-                }
-            ]
+        message = llm_rails(
+            setting=setting,
+            rails_app=app,
+            firebase_app=firebase_app,
+            query=chunks[0],
+            image_search=image_search,
         )
         result = json.dumps(message["content"])
         return parseJsonFromCompletion(result)
@@ -84,18 +140,12 @@ def processLargeText(
                     + "]\n"
                     + "Remember not answering yet. Just acknowledge you received this part with the message 'Part 1/10 received' and wait for the next part."
                 )
-                app.generate(
-                    messages=[
-                        {
-                            "role": "user",
-                            "content": rails_input_with_args(
-                                query=chunk_query,
-                                model=model,
-                                uuid=uuid,
-                                image_search=image_search,
-                            ),
-                        }
-                    ]
+                llm_rails(
+                    setting=setting,
+                    rails_app=app,
+                    firebase_app=firebase_app,
+                    query=chunk_query,
+                    image_search=image_search,
                 )
             else:
                 last_query = (
@@ -111,18 +161,12 @@ def processLargeText(
                     + "]\n"
                     + "ALL PART SENT. Now you can continue processing the request."
                 )
-                message = app.generate(
-                    messages=[
-                        {
-                            "role": "user",
-                            "content": rails_input_with_args(
-                                query=last_query,
-                                model=model,
-                                uuid=uuid,
-                                image_search=image_search,
-                            ),
-                        }
-                    ]
+                message = llm_rails(
+                    setting=setting,
+                    rails_app=app,
+                    firebase_app=firebase_app,
+                    query=last_query,
+                    image_search=image_search,
                 )
                 result = json.dumps(message["content"])
                 return parseJsonFromCompletion(result)
@@ -130,19 +174,24 @@ def processLargeText(
 
 
 def getCompletion(
-    query,
-    model=DEFAULT_GPT_MODEL,
-    uuid="",
-    image_search=True,
+    query: str,
+    setting: ReqModel,
+    firebase_app: firebase_admin.App,
+    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,
+        image_search=image_search,
+        firebase_app=firebase_app,
     )
 
 
@@ -156,10 +205,10 @@ def getCompletionOnly(
     return chain_data
 
 
-def query_image_ask(image_content, message, uuid):
+def query_image_ask(image_content, message, setting: ReqModel):
     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, image_search=False, setting=setting)
         # chain_data = json.loads(data.replace("'", '"'))
         # chain_data = json.loads(data)
         if data["program"] == "image":
@@ -169,9 +218,9 @@ def query_image_ask(image_content, message, uuid):
     return False
 
 
-def getTextFromImage(filename):
+def getTextFromImage(filename: str, firebase_app: firebase_admin.App) -> str:
     # Create a reference to the image file you want to download
-    bucket = storage.bucket()
+    bucket = storage.bucket(app=firebase_app)
     blob = bucket.blob(FIREBASE_STORAGE_ROOT.__add__(filename))
     download_url = ""
 
@@ -214,15 +263,17 @@ 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: ReqModel, query: str):
+    llm = ChatOpenAI(
+        model_name=DEFAULT_GPT_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, setting=setting)
 
     if (
         message
@@ -240,13 +291,20 @@ 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,
+    image_search: bool,
+    page_content: str,
+    document_id: str,
+) -> str:
     # convert json with params for rails.
     json_query_with_params = {
         "query": query,
-        "model": model,
-        "uuid": uuid,
         "image_search": image_search,
+        "page_content": page_content,
+        "document_id": document_id,
+        "setting": setting.to_json(),
     }
     return json.dumps(json_query_with_params)
 

Brain/src/router/api.py

@@ -1,9 +1,11 @@
 import json
-import os
 
 from Brain.src.common.assembler import Assembler
 from Brain.src.common.brain_exception import BrainException
-from Brain.src.common.utils import ProgramType
+from Brain.src.common.utils import ProgramType, DEFAULT_GPT_MODEL
+from Brain.src.firebase.firebase import (
+    firebase_admin_with_setting,
+)
 from Brain.src.model.image_model import ImageModel
 from Brain.src.model.requests.request_model import (
     Notification,
@@ -21,9 +23,8 @@ from Brain.src.rising_plugin.risingplugin import (
     getCompletion,
     getTextFromImage,
     query_image_ask,
-    handle_chat_completion,
 )
-from Brain.src.firebase.cloudmessage import send_message, get_tokens
+from Brain.src.firebase.cloudmessage import CloudMessage
 from Brain.src.rising_plugin.image_embedding import embed_image_text, query_image_text
 
 from Brain.src.logs import logger
@@ -35,7 +36,7 @@ from Brain.src.service.feedback_service import FeedbackService
 from Brain.src.service.llm.chat_service import ChatService
 from Brain.src.service.twilio_service import TwilioService
 
-from fastapi import APIRouter, Request, Depends
+from fastapi import APIRouter, Depends
 
 router = APIRouter()
 
@@ -45,9 +46,8 @@ def construct_blueprint_api() -> APIRouter:
     assembler = Assembler()
 
     # Service
-    feedback_service = FeedbackService()
+
     command_service = CommandService()
-    contacts_service = ContactsService()
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
@@ -60,6 +60,16 @@ def construct_blueprint_api() -> APIRouter:
     def send_notification(
         data: Notification, client_info: ClientInfo = Depends(get_client_info)
     ):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+
+        # cloud message
+        cloud_message = CloudMessage(firebase_app=firebase_app)
+
+        # parsing params
         query = data.message
         token = data.token
         uuid = data.uuid
@@ -67,10 +77,13 @@ 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, setting=assembler.to_req_model(data), firebase_app=firebase_app
+        )
 
         # check contact querying
         try:
+            contacts_service = ContactsService(setting=setting)
             if result["program"] == ProgramType.CONTACT:
                 # querying contacts to getting its expected results
                 contacts_results = contacts_service.query_contacts(
@@ -80,7 +93,7 @@ def construct_blueprint_api() -> APIRouter:
 
             notification = {"title": "alert", "content": json.dumps(result)}
 
-            state, value = send_message(notification, [token])
+            state, value = cloud_message.send_message(notification, [token])
             return assembler.to_response(200, value, result)
         except Exception as e:
             logger.error(
@@ -103,21 +116,34 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/uploadImage")
     def upload_image(data: UploadImage):
-        image_model = ImageModel()
-        token = data.token
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # cloud message
+        try:
+            cloud_message = CloudMessage(firebase_app=firebase_app)
+
+            image_model = ImageModel()
+            token = data.token
 
-        image_model.image_name = data.image_name
-        image_model.uuid = data.uuid
-        image_model.status = data.status
+            image_model.image_name = data.image_name
+            image_model.uuid = data.uuid
+            image_model.status = data.status
 
-        image_model.image_text = getTextFromImage(image_model.image_name)
+            image_model.image_text = getTextFromImage(
+                filename=image_model.image_name, firebase_app=firebase_app
+            )
 
-        embed_result = embed_image_text(image_model)
+            embed_result = embed_image_text(image=image_model, setting=setting)
 
-        notification = {"title": "alert", "content": embed_result}
+            notification = {"title": "alert", "content": embed_result}
 
-        state, value = send_message(notification, [token])
-        return assembler.to_response(200, value, image_model.to_json())
+            state, value = cloud_message.send_message(notification, [token])
+            return assembler.to_response(200, value, image_model.to_json())
+        except BrainException as ex:
+            return ex.get_response_exp()
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
@@ -133,27 +159,40 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/image_relatedness")
     def image_relatedness(data: ImageRelatedness):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+
+        # cloud message
+        cloud_message = CloudMessage(firebase_app=firebase_app)
+        # parsing params
         image_name = data.image_name
         message = data.message
         token = data.token
         uuid = data.uuid
 
-        image_content = getTextFromImage(image_name)
+        image_content = getTextFromImage(filename=image_name, firebase_app=firebase_app)
         # check message type
         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, setting=setting
+            ):
                 image_response["image_desc"] = image_content
             else:
-                relatedness_data = query_image_text(image_content, message, uuid)
+                relatedness_data = query_image_text(image_content, message, setting)
 
                 image_response["image_name"] = relatedness_data
         except ValueError as e:
             print("image_relatedness parsing error for message chain data")
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
 
         notification = {"title": "alert", "content": json.dumps(image_response)}
-        state, value = send_message(notification, [token])
+        state, value = cloud_message.send_message(notification, [token])
 
         return assembler.to_response(
             code=200,
@@ -177,6 +216,12 @@ def construct_blueprint_api() -> APIRouter:
     @router.post("/feedback")
     def add_feedback(data: Feedback):
         try:
+            # firebase admin init
+            setting, firebase_app = firebase_admin_with_setting(data)
+
+            # cloud message
+            cloud_message = CloudMessage(firebase_app=firebase_app)
+            feedback_service = FeedbackService(firebase_app=firebase_app)
             token = data.token
             uuid = data.uuid
 
@@ -193,6 +238,8 @@ def construct_blueprint_api() -> APIRouter:
             # add the feedback
             feedback_service.add(feedback)
         except Exception as e:
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
             return assembler.to_response(400, "failed to add", "")
         return assembler.to_response(200, "added successfully", "")
 
@@ -200,8 +247,17 @@ def construct_blueprint_api() -> APIRouter:
         status_code=200, schema={"message": "message", "result": "test_result"}
     )"""
 
-    @router.get("/feedback/{search}/{rating}")
-    def get_feedback(search: str, rating: int):
+    @router.post("/feedback/{search}/{rating}")
+    def get_feedback(search: str, rating: int, data: BasicReq):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+
+        # cloud message
+        cloud_message = CloudMessage(firebase_app=firebase_app)
+        feedback_service = FeedbackService(firebase_app=firebase_app)
         result = feedback_service.get(search, rating)
         return assembler.to_response(200, "added successfully", result)
 
@@ -209,8 +265,8 @@ def construct_blueprint_api() -> APIRouter:
         status_code=200, schema={"message": "message", "result": "test_result"}
     )"""
 
-    @router.get("/commands")
-    def get_commands():
+    @router.post("/commands")
+    def get_commands(data: BasicReq):
         result = command_service.get()
         return assembler.to_response(
             200, "success", {"program": "help_command", "content": result}
@@ -238,14 +294,21 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/chat_rising")
     def message_agent(data: ChatRising):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+
+        # cloud message
+        cloud_message = CloudMessage(firebase_app=firebase_app)
         try:
             token = data.token
             uuid = data.uuid
             histories = assembler.to_array_message_model(data.history)  # json array
             user_input = data.user_input
-            model = data.model
             """init chat service with model"""
-            chat_service = ChatService(ai_name=uuid, llm_model=model)
+            chat_service = ChatService(ai_name=uuid, llm_model=DEFAULT_GPT_MODEL)
             # getting chat response from rising ai
             assistant_reply = chat_service.chat_with_ai(
                 prompt="",
@@ -283,6 +346,11 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/send_sms")
     def send_sms(data: SendSMS):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return assembler.to_response(ex.code, ex.message, "")
         try:
             token = data.token
             uuid = data.uuid
@@ -316,6 +384,11 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/train/contacts")
     def train_contacts(data: TrainContacts):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return assembler.to_response(ex.code, ex.message, "")
         try:
             token = data.token
             uuid = data.uuid
@@ -325,8 +398,11 @@ def construct_blueprint_api() -> APIRouter:
             for contact in data.contacts:
                 contacts.append(assembler.to_contact_model(contact))
             # train contact
+            contacts_service = ContactsService(setting=setting)
             contacts_service.train(uuid, contacts)
         except Exception as e:
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
             return assembler.to_response(400, "Failed to train contacts", "")
         return assembler.to_response(200, "Trained successfully", "")
 
@@ -342,14 +418,22 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/train/contacts/delete")
     def delete_all_contacts(data: BasicReq):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return assembler.to_response(ex.code, ex.message, "")
         try:
             token = data.token
             uuid = data.uuid
 
             # parsing contacts
             # train contact
+            contacts_service = ContactsService(setting=setting)
             contacts_service.delete_all(uuid)
         except Exception as e:
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
             return assembler.to_response(400, "Failed to delete contacts", "")
         return assembler.to_response(
             200, "Deleted all contacts from pinecone successfully", ""

Brain/src/router/browser_router.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter, Request, Depends
 
 from Brain.src.common.assembler import Assembler
+from Brain.src.common.brain_exception import BrainException
 from Brain.src.common.program_type import ProgramType
 from Brain.src.common.utils import parseUrlFromStr
+from Brain.src.firebase.firebase import firebase_admin_with_setting
 from Brain.src.model.requests.request_model import BrowserItem
 from Brain.src.service.browser_service import BrowserService
 
@@ -28,6 +30,12 @@ def construct_blueprint_browser_api() -> APIRouter:
 
     @router.post("/item")
     def get_item(data: BrowserItem):
+        # firebase admin init
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+
         item_link = ""
         try:
             token = data.token
@@ -37,6 +45,8 @@ def construct_blueprint_browser_api() -> APIRouter:
             # train contact
             item_link = browser_service.query_item(items=data.items, query=data.prompt)
         except Exception as e:
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
             return assembler.to_response(400, "Failed to get item in a browser", "")
         return assembler.to_response(
             200,

Brain/src/router/train_router.py

@@ -1,8 +1,11 @@
 from fastapi import APIRouter
 
 from Brain.src.common.assembler import Assembler
+from Brain.src.common.brain_exception import BrainException
+from Brain.src.firebase.firebase import firebase_admin_with_setting
 from Brain.src.model.requests.request_model import (
     Document,
+    BasicReq,
 )
 from Brain.src.service.train_service import TrainService
 
@@ -13,15 +16,19 @@ def construct_blueprint_train_api() -> APIRouter:
     # Assembler
     assembler = Assembler()
 
-    # Services
-    train_service = TrainService()
-
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
     )"""
 
     @router.get("")
-    def read_all_documents():
+    def read_all_documents(data: BasicReq):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         try:
             result = train_service.read_all_documents()
         except Exception as e:
@@ -31,8 +38,15 @@ def construct_blueprint_train_api() -> APIRouter:
     """@generator.response( status_code=200, schema={"message": "message", "result": {"document_id": "document_id", 
     "page_content":"page_content"}} )"""
 
-    @router.get("/all")
-    def train_all_documents():
+    @router.post("/all")
+    def train_all_documents(data: BasicReq):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         try:
             result = train_service.train_all_documents()
         except Exception as e:
@@ -42,8 +56,15 @@ def construct_blueprint_train_api() -> APIRouter:
     """@generator.response( status_code=200, schema={"message": "message", "result": {"document_id": "document_id", 
     "page_content":"page_content"}} )"""
 
-    @router.get("/{document_id}")
-    def read_one_document(document_id: str):
+    @router.post("/{document_id}")
+    def read_one_document(document_id: str, data: BasicReq):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         if document_id != "all":
             try:
                 result = train_service.read_one_document(document_id)
@@ -63,6 +84,13 @@ def construct_blueprint_train_api() -> APIRouter:
 
     @router.post("")
     def create_document_train(data: Document):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         try:
             result = train_service.create_one_document(data.page_content)
         except Exception as e:
@@ -84,6 +112,13 @@ def construct_blueprint_train_api() -> APIRouter:
 
     @router.put("")
     def update_one_document(data: Document):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         try:
             result = train_service.update_one_document(
                 data.document_id, data.page_content
@@ -103,11 +138,20 @@ def construct_blueprint_train_api() -> APIRouter:
     )
     @generator.response( status_code=200, schema={"message": "message", "result": {"document_id": "document_id"}} )"""
 
-    @router.delete("/{document_id}")
-    def delete_one_document(document_id: str):
+    @router.post("/delete/{document_id}")
+    def delete_one_document(document_id: str, data: BasicReq):
+        # parsing params
+        try:
+            setting, firebase_app = firebase_admin_with_setting(data)
+        except BrainException as ex:
+            return ex.get_response_exp()
+        # Services
+        train_service = TrainService(firebase_app=firebase_app, setting=setting)
         try:
             result = train_service.delete_one_document(document_id)
         except Exception as e:
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
             return assembler.to_response(400, "fail to delete one train", "")
         return assembler.to_response(
             200, "deleted one document and train data successfully", result

Brain/src/service/contact_service.py

@@ -1,6 +1,7 @@
 """service to manage contacts"""
 from typing import List, Any
 
+from Brain.src.model.req_model import ReqModel
 from Brain.src.rising_plugin.csv_embed import get_embed
 from Brain.src.rising_plugin.pinecone_engine import (
     get_pinecone_index_namespace,
@@ -16,6 +17,9 @@ from Brain.src.model.contact_model import ContactModel, ContactStatus
 
 
 class ContactsService:
+    def __init__(self, setting: ReqModel):
+        self.setting = setting
+
     """train contacts (getting embedding) and update pinecone with embeddings by contact_id
     train datatype:
     key: contactId
@@ -33,13 +37,23 @@ class ContactsService:
             # create | update | delete pinecone
             if contact.status == ContactStatus.CREATED:
                 add_pinecone(
-                    namespace=pinecone_namespace, key=key, value=vectoring_values
+                    namespace=pinecone_namespace,
+                    key=key,
+                    value=vectoring_values,
+                    setting=self.setting,
                 )
             elif contact.status == ContactStatus.DELETED:
-                delete_pinecone(namespace=pinecone_namespace, key=key)
+                delete_pinecone(
+                    namespace=pinecone_namespace,
+                    key=key,
+                    setting=self.setting,
+                )
             elif contact.status == ContactStatus.UPDATED:
                 update_pinecone(
-                    namespace=pinecone_namespace, key=key, value=vectoring_values
+                    namespace=pinecone_namespace,
+                    key=key,
+                    value=vectoring_values,
+                    setting=self.setting,
                 )
 
     """"query contact with search text
@@ -47,7 +61,7 @@ class ContactsService:
 
     def query_contacts(self, uuid: str, search: str) -> List[str]:
         vector_data = get_embed(search)
-        index = init_pinecone(PINECONE_INDEX_NAME)
+        index = init_pinecone(index_name=PINECONE_INDEX_NAME, setting=self.setting)
         relatedness_data = index.query(
             vector=vector_data,
             top_k=5,
@@ -63,7 +77,9 @@ class ContactsService:
     """delete all items in the specific nanespace"""
 
     def delete_all(self, uuid: str) -> Any:
-        return delete_all_pinecone(self.get_pinecone_index_namespace(uuid))
+        return delete_all_pinecone(
+            namespace=self.get_pinecone_index_namespace(uuid), setting=self.setting
+        )
 
     """get pinecone namespace of pinecone"""
 

Brain/src/service/feedback_service.py

@@ -1,5 +1,7 @@
 from os import remove
+from typing import Any
 
+import firebase_admin
 from firebase_admin import firestore
 
 
@@ -9,18 +11,26 @@ from Brain.src.model.feedback_model import FeedbackModel
 
 
 class FeedbackService:
-    def __init__(self):
-        self.db = firestore.client()
+    db: Any
+    feedbacks_ref: Any
+
+    def __init__(self, firebase_app: firebase_admin.App):
+        self.firebase_app = firebase_app
+
+    def init_firestore(self):
+        self.db = firestore.client(app=self.firebase_app)
         self.feedbacks_ref = self.db.collection("feedbacks")
 
     """add a new feedback"""
 
     def add(self, feedback: FeedbackModel):
+        self.init_firestore()
         return self.feedbacks_ref.document().set(feedback.to_json())
 
     """get list of feedback"""
 
     def get(self, search, rating):
+        self.init_firestore()
         if rating == 0:
             query = self.feedbacks_ref.where("rating", "!=", rating)
         else:

Brain/src/service/train_service.py

@@ -1,11 +1,12 @@
 """service to manage trains"""
-from typing import List, Any
+from typing import Any
 
+import firebase_admin
+
+from Brain.src.model.req_model import ReqModel
 from Brain.src.rising_plugin.csv_embed import get_embed
 from Brain.src.rising_plugin.pinecone_engine import (
     get_pinecone_index_namespace,
-    update_pinecone,
-    init_pinecone,
     delete_pinecone,
     add_pinecone,
     delete_all_pinecone,
@@ -28,13 +29,21 @@ class TrainService:
     key: document_id
     values: {page_content}"""
 
-    def __init__(self):
-        self.db = firestore.client()
+    db: Any
+    documents_ref: Any
+
+    def __init__(self, firebase_app: firebase_admin.App, setting: ReqModel):
+        self.firebase_app = firebase_app
+        self.setting = setting
+
+    def init_firestore(self):
+        self.db = firestore.client(app=self.firebase_app)
         self.documents_ref = self.db.collection("documents")
 
     """read all documents from firestore"""
 
     def read_all_documents(self):
+        self.init_firestore()
         query = self.documents_ref.order_by("timestamp")
         docs = query.stream()
         result = []
@@ -48,6 +57,7 @@ class TrainService:
     """read one document from firestore"""
 
     def read_one_document(self, document_id: str):
+        self.init_firestore()
         doc = self.documents_ref.document(document_id).get()
         if doc.exists:
             return {
@@ -60,6 +70,7 @@ class TrainService:
     """create a new document and train it"""
 
     def create_one_document(self, page_content: str):
+        self.init_firestore()
         # Auto-generate document ID
         auto_generated_doc_ref = self.documents_ref.document()
         auto_generated_doc_ref.set(to_json(page_content))
@@ -70,6 +81,7 @@ class TrainService:
     """update a document by using id and train it"""
 
     def update_one_document(self, document_id: str, page_content: str):
+        self.init_firestore()
         self.documents_ref.document(document_id).update(to_json(page_content))
         self.train_one_document(document_id, page_content)
         return {"document_id": document_id, "page_content": page_content}
@@ -77,11 +89,13 @@ class TrainService:
     """delete a document by using document_id"""
 
     def delete_one_document(self, document_id: str):
+        self.init_firestore()
         self.documents_ref.document(document_id).delete()
         self.delete_one_pinecone(document_id)
         return {"document_id": document_id}
 
     def train_all_documents(self) -> str:
+        self.init_firestore()
         self.delete_all()
         documents = self.read_all_documents()
         result = list()
@@ -93,11 +107,17 @@ class TrainService:
             value = f'{item["page_content"]}'
             # get vectoring data(embedding data)
             vectoring_values = get_embed(value)
-            add_pinecone(namespace=pinecone_namespace, key=key, value=vectoring_values)
+            add_pinecone(
+                namespace=pinecone_namespace,
+                key=key,
+                value=vectoring_values,
+                setting=self.setting,
+            )
 
         return "trained all documents successfully"
 
     def train_one_document(self, document_id: str, page_content: str) -> None:
+        self.init_firestore()
         pinecone_namespace = self.get_pinecone_index_namespace()
         result = list()
         query_result = get_embed(page_content)
@@ -106,16 +126,32 @@ class TrainService:
         value = f"{page_content}, {query_result}"
         # get vectoring data(embedding data)
         vectoring_values = get_embed(value)
-        add_pinecone(namespace=pinecone_namespace, key=key, value=vectoring_values)
+        add_pinecone(
+            namespace=pinecone_namespace,
+            key=key,
+            value=vectoring_values,
+            setting=self.setting,
+        )
 
     def delete_all(self) -> Any:
-        return delete_all_pinecone(self.get_pinecone_index_namespace())
+        self.init_firestore()
+        return delete_all_pinecone(
+            namespace=self.get_pinecone_index_namespace(),
+            setting=self.setting,
+        )
 
     def delete_one_pinecone(self, document_id: str) -> Any:
-        return delete_pinecone(self.get_pinecone_index_namespace(), document_id)
+        self.init_firestore()
+        return delete_pinecone(
+            namespace=self.get_pinecone_index_namespace(),
+            key=document_id,
+            setting=self.setting,
+        )
 
     def get_pinecone_index_namespace(self) -> str:
+        self.init_firestore()
         return get_pinecone_index_namespace(f"trains")
 
     def get_pinecone_index_train_namespace(self) -> str:
+        self.init_firestore()
         return get_pinecone_index_namespace(f"trains")

Brain/tests/conftest.py

@@ -2,10 +2,6 @@ import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 
-from Brain.src.firebase.firebase import initialize_app
-
-initialize_app()
-
 
 @pytest.fixture(scope="module")
 def test_client():

Brain/tests/functional/test_recipes.py

@@ -1,41 +1,63 @@
 import re
 
+from Brain.src.firebase.cloudmessage import CloudMessage
 from Brain.src.firebase.firebase import initialize_app
+from Brain.src.model.req_model import ReqModel
 from Brain.src.rising_plugin.risingplugin import getCompletion, getTextFromImage
-from Brain.src.firebase.cloudmessage import send_message
-from Brain.src.firebase.cloudmessage import get_tokens
 from Brain.src.rising_plugin.image_embedding import query_image_text
 
 TEST_IAMGE_NAME = "0ddffe51-3763-48d9-ab74-2086de529217"
 TEST_UUID = "TEST_UUID"
+test_setting = ReqModel(
+    data={
+        "token": "test-token",
+        "uuid": TEST_UUID,
+        "openai_key": "",
+        "pinecone_key": "",
+        "pinecone_env": "",
+        "firebase_key": "",
+        "settings": {"temperature": 0.6},
+    }
+)
+
+firebase_app = initialize_app(test_setting)
 
 
 def test_langchain():
     error = "Error happened while analyzing your prompt. Please ask me again"
-    result = getCompletion(query="open three.js website", uuid=TEST_UUID)
+    result = getCompletion(
+        query="open three.js website", setting=test_setting, firebase_app=firebase_app
+    )
     print(result)
     assert result != error
 
 
 def test_image2text():
     error = "Error happened while analyzing your prompt. Please ask me again"
-    result = getTextFromImage(TEST_IAMGE_NAME)
+    result = getTextFromImage(filename=TEST_IAMGE_NAME, firebase_app=firebase_app)
     print(result)
     assert result != error
 
 
 def test_firebase_cloud_message():
-    token_list = get_tokens()
+    cloud_message = CloudMessage(firebase_app=firebase_app)
+    token_list = cloud_message.get_tokens()
     notification = {"title": "alert", "content": "test"}
 
     pattern = r"send to \d+ devices, with \d+ successed, with \d+ failed."
 
-    state, value = send_message(notification, token_list)
+    state, value = cloud_message.send_message(notification, token_list)
     assert re.match(pattern, value)
 
 
 def test_query_image_text():
     error = "Error happened in querying image & text"
-    result = query_image_text(getTextFromImage(TEST_IAMGE_NAME), "", TEST_UUID)
+    result = query_image_text(
+        image_content=getTextFromImage(
+            filename=TEST_IAMGE_NAME, firebase_app=firebase_app
+        ),
+        message="",
+        setting=test_setting,
+    )
     print(result)
     assert result != error

app.py

@@ -6,8 +6,6 @@ import uvicorn
 from Brain.src.router.browser_router import construct_blueprint_browser_api
 from Brain.src.router.train_router import construct_blueprint_train_api
 
-initialize_app()
-
 from Brain.src.router.api import construct_blueprint_api
 
 app = FastAPI()
@@ -26,9 +24,7 @@ app.include_router(
     construct_blueprint_browser_api(), prefix="/browser", tags=["ai_browser"]
 )
 
-app.include_router(
-    construct_blueprint_train_api(), prefix="/train", tags=["ai_train"]
-)
+app.include_router(construct_blueprint_train_api(), prefix="/train", tags=["ai_train"])
 
 
 if __name__ == "__main__":