feature(#9): firebase key management

Brain/src/common/utils.py

@@ -3,6 +3,7 @@ import os
 import re
 
 from firebase_admin import credentials
+from Brain.src.model.req_model import ReqModel
 
 # env variables
 DEFAULT_HOST_NAME = "test3-83ffc.appspot.com"
@@ -41,14 +42,14 @@ AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
 HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
 
 
-def get_firebase_cred():
+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(FIREBASE_ENV)
+        cred = json.loads(setting.firebase_key)
         return credentials.Certificate(cred)
 
 

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,29 @@
+from typing import Any
+
 import firebase_admin
+
+from Brain.src.common.assembler import Assembler
 from Brain.src.common.utils import get_firebase_cred, FIREBASE_STORAGE_BUCKET
+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:
+    return firebase_admin.initialize_app(
+        get_firebase_cred(setting),
+        {"storageBucket": FIREBASE_STORAGE_BUCKET},
+        name=get_firebase_admin_name(setting.uuid),
     )
+
+
+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)
+
+    firebase_app = initialize_app(setting)
+    return setting, firebase_app

Brain/src/model/req_model.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from Brain.src.common.utils import DEFAULT_HOST_NAME
+DEFAULT_HOST_NAME = "test3-83ffc.appspot.com"
 
 
 class ReqModel:

Brain/src/model/requests/request_model.py

@@ -4,14 +4,6 @@ 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"""
 
 

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

@@ -80,46 +80,24 @@ query is json string with below format
 async def general_question(query):
     """init falcon model"""
     falcon_llm = FalconLLM()
-    """step 0: convert string to json"""
-    index = init_pinecone(PINECONE_INDEX_NAME)
-    train_service = TrainService()
+    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 parms 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(),
-    )
-
-    if len(relatedness_data["matches"]) == 0:
-        return str({"program": "message", "content": ""})
-    document_id = relatedness_data["matches"][0]["id"]
-    docs = []
-    document = train_service.read_one_document(document_id)
-    docs.append(Document(page_content=document["page_content"], metadata=""))
-
+    docs.append(Document(page_content=page_content, metadata=""))
     """ 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
-        )
+    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
@@ -130,8 +108,8 @@ async def general_question(query):
                 }
         """ 2. check program is message to handle it with falcon llm """
         if result["program"] == "message":
-            if model == FALCON_7B:
-                result["content"] = falcon_llm.query(question=query)
+            """FALCON_7B:"""
+            result["content"] = falcon_llm.query(question=query)
         return str(result)
     except ValueError as e:
         # Check sms and browser query

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,12 +17,16 @@ 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.utils import (
     OPENAI_API_KEY,
     FIREBASE_STORAGE_ROOT,
     DEFAULT_GPT_MODEL,
     parseJsonFromCompletion,
+    PINECONE_INDEX_NAME,
 )
 from .image_embedding import (
     query_image_text,
@@ -27,6 +34,7 @@ from .image_embedding import (
 )
 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__))
@@ -42,28 +50,65 @@ 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(PINECONE_INDEX_NAME)
+    train_service = TrainService(firebase_app=firebase_app)
+
+    """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(),
+    )
+
+    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(
     setting: ReqModel,
     app: any,
     chunks: any,
-    model: str,
-    uuid: str = "",
+    firebase_app: firebase_admin.App,
     image_search: bool = True,
 ):
     if len(chunks) == 1:
-        message = app.generate(
-            messages=[
-                {
-                    "role": "user",
-                    "content": rails_input_with_args(
-                        setting=setting,
-                        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)
@@ -92,19 +137,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(
-                                setting=setting,
-                                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 = (
@@ -120,19 +158,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(
-                                setting=setting,
-                                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)
@@ -142,8 +173,7 @@ def processLargeText(
 def getCompletion(
     query: str,
     setting: ReqModel,
-    model: str = DEFAULT_GPT_MODEL,
-    uuid: str = "",
+    firebase_app: firebase_admin.App,
     image_search: bool = True,
 ):
     llm = get_llm(model=DEFAULT_GPT_MODEL, setting=setting).get_llm()
@@ -157,9 +187,8 @@ def getCompletion(
         setting=setting,
         app=app,
         chunks=chunks,
-        model=model,
-        uuid=uuid,
         image_search=image_search,
+        firebase_app=firebase_app,
     )
 
 
@@ -173,12 +202,10 @@ def getCompletionOnly(
     return chain_data
 
 
-def query_image_ask(image_content, message, uuid, setting: BasicReq):
+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, setting=setting
-        )
+        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":
@@ -233,15 +260,17 @@ response:
 
 
 # Define a content filter function
-def filter_guardrails(setting: BasicReq, model: any, query: str):
-    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=setting.openai_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, setting=setting)
+    message = processLargeText(app=app, chunks=chunks, setting=setting)
 
     if (
         message
@@ -260,14 +289,18 @@ compose json_string for rails input with its arguments
 
 
 def rails_input_with_args(
-    setting: ReqModel, query: str, model: str, uuid: str, image_search: bool
+    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

@@ -4,6 +4,11 @@ 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.firebase.firebase import (
+    initialize_app,
+    get_firebase_admin_name,
+    firebase_admin_with_setting,
+)
 from Brain.src.model.image_model import ImageModel
 from Brain.src.model.requests.request_model import (
     Notification,
@@ -23,7 +28,7 @@ from Brain.src.rising_plugin.risingplugin import (
     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
@@ -60,6 +65,13 @@ def construct_blueprint_api() -> APIRouter:
     def send_notification(
         data: Notification, client_info: ClientInfo = Depends(get_client_info)
     ):
+        # firebase admin init
+        setting, firebase_app = firebase_admin_with_setting(data)
+
+        # cloud message
+        cloud_message = CloudMessage(firebase_app=firebase_app)
+
+        # parsing params
         query = data.message
         token = data.token
         uuid = data.uuid
@@ -68,7 +80,7 @@ def construct_blueprint_api() -> APIRouter:
             query = f"{query} in a web browser"
 
         result = getCompletion(
-            query=query, uuid=uuid, setting=assembler.to_req_model(data)
+            query=query, setting=assembler.to_req_model(data), firebase_app=firebase_app
         )
 
         # check contact querying
@@ -82,7 +94,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(
@@ -105,6 +117,13 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/uploadImage")
     def upload_image(data: UploadImage):
+        # cloud message
+        cloud_message = CloudMessage()
+        # parsing params
+        setting = assembler.to_req_model(data)
+        # firebase admin init
+        initialize_app(setting)
+
         image_model = ImageModel()
         token = data.token
 
@@ -118,7 +137,7 @@ def construct_blueprint_api() -> APIRouter:
 
         notification = {"title": "alert", "content": embed_result}
 
-        state, value = send_message(notification, [token])
+        state, value = cloud_message.send_message(notification, [token])
         return assembler.to_response(200, value, image_model.to_json())
 
     """@generator.response(
@@ -135,6 +154,9 @@ def construct_blueprint_api() -> APIRouter:
 
     @router.post("/image_relatedness")
     def image_relatedness(data: ImageRelatedness):
+        # cloud message
+        cloud_message = CloudMessage()
+        # parsing params
         image_name = data.image_name
         message = data.message
         token = data.token
@@ -157,7 +179,7 @@ def construct_blueprint_api() -> APIRouter:
             print("image_relatedness parsing error for message chain data")
 
         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,

Brain/src/router/train_router.py

@@ -1,8 +1,10 @@
 from fastapi import APIRouter
 
 from Brain.src.common.assembler import Assembler
+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 +15,16 @@ 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
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         try:
             result = train_service.read_all_documents()
         except Exception as e:
@@ -32,7 +35,11 @@ def construct_blueprint_train_api() -> APIRouter:
     "page_content":"page_content"}} )"""
 
     @router.get("/all")
-    def train_all_documents():
+    def train_all_documents(data: BasicReq):
+        # parsing params
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         try:
             result = train_service.train_all_documents()
         except Exception as e:
@@ -43,7 +50,11 @@ def construct_blueprint_train_api() -> APIRouter:
     "page_content":"page_content"}} )"""
 
     @router.get("/{document_id}")
-    def read_one_document(document_id: str):
+    def read_one_document(document_id: str, data: BasicReq):
+        # parsing params
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         if document_id != "all":
             try:
                 result = train_service.read_one_document(document_id)
@@ -63,6 +74,10 @@ def construct_blueprint_train_api() -> APIRouter:
 
     @router.post("")
     def create_document_train(data: Document):
+        # parsing params
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         try:
             result = train_service.create_one_document(data.page_content)
         except Exception as e:
@@ -84,6 +99,10 @@ def construct_blueprint_train_api() -> APIRouter:
 
     @router.put("")
     def update_one_document(data: Document):
+        # parsing params
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         try:
             result = train_service.update_one_document(
                 data.document_id, data.page_content
@@ -104,7 +123,11 @@ 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):
+    def delete_one_document(document_id: str, data: BasicReq):
+        # parsing params
+        setting, firebase_app = firebase_admin_with_setting(data)
+        # Services
+        train_service = TrainService(firebase_app=firebase_app)
         try:
             result = train_service.delete_one_document(document_id)
         except Exception as e:

Brain/src/service/feedback_service.py

@@ -1,4 +1,5 @@
 from os import remove
+from typing import Any
 
 from firebase_admin import firestore
 
@@ -9,18 +10,23 @@ from Brain.src.model.feedback_model import FeedbackModel
 
 
 class FeedbackService:
-    def __init__(self):
+    db: Any
+    feedbacks_ref: Any
+
+    def init_firestore(self):
         self.db = firestore.client()
         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,6 +1,8 @@
 """service to manage trains"""
 from typing import List, Any
 
+import firebase_admin
+
 from Brain.src.rising_plugin.csv_embed import get_embed
 from Brain.src.rising_plugin.pinecone_engine import (
     get_pinecone_index_namespace,
@@ -28,13 +30,20 @@ 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):
+        self.firebase_app = firebase_app
+
+    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()
@@ -98,6 +112,7 @@ class TrainService:
         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)
@@ -109,13 +124,17 @@ class TrainService:
         add_pinecone(namespace=pinecone_namespace, key=key, value=vectoring_values)
 
     def delete_all(self) -> Any:
+        self.init_firestore()
         return delete_all_pinecone(self.get_pinecone_index_namespace())
 
     def delete_one_pinecone(self, document_id: str) -> Any:
+        self.init_firestore()
         return delete_pinecone(self.get_pinecone_index_namespace(), document_id)
 
     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")

app.py

@@ -5,8 +5,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()