feature: added plugin as sub package and updated all the response format.

requirements.txt

@@ -1,6 +1,5 @@
-aiohttp==3.8.4
-aiosignal==1.3.1
-astroid==2.15.3
+langchain >= 0.0.148
+replicate==0.8.1
 async-timeout==4.0.2
 attrs==22.2.0
 black==23.3.0
@@ -64,38 +63,8 @@ pinecone-client==2.2.1
 platformdirs==3.2.0
 pluggy==1.0.0
 proto-plus==1.22.2
-protobuf==4.22.3
-pyasn1==0.4.8
-pyasn1-modules==0.2.8
-pycparser==2.21
-PyJWT==2.6.0
-pylint==2.17.2
-pyparsing==3.0.9
-pystache==0.6.0
-pytest==7.3.0
-python-dateutil==2.8.2
-python-dotenv==1.0.0
-PyYAML==6.0
-regex==2023.3.23
-replicate==0.8.1
-requests==2.28.2
-rsa==4.9
-six==1.16.0
-slack==0.0.2
-SQLAlchemy==1.4.47
-tenacity==8.2.2
-tiktoken==0.3.3
-tomli==2.0.1
-tomlkit==0.11.7
-tqdm==4.65.0
-typing-inspect==0.8.0
-typing_extensions==4.5.0
-uritemplate==4.1.1
-urllib3==1.26.15
-virtualenv==20.21.0
-Werkzeug==2.2.3
 win32-setctime==1.1.0
 wrapt==1.15.0
 yarl==1.8.2
 twilio==8.2.1
-rising-plugin==0.1.8
+nemoguardrails==0.2.0

sauce_tests/01 Send Notification/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /sendNotification

sauce_tests/02 Upload Image/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /uploadImage

sauce_tests/03 Image Relatedness/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /image_relatedness

sauce_tests/04 Add Feedback/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /feedback

sauce_tests/05 Get Feedback/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /feedback/test/1

sauce_tests/06 Get Commands/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /commands

sauce_tests/07 Rising Chat/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /chat_rising

sauce_tests/08 Train Contacts/input.yaml

@@ -5,7 +5,7 @@
       value: https://
     - id: variable
       name: domain
-      value: smartphone.herokuapp.com
+      value: ttt246-brain.hf.space
     - id: variable
       name: endpoint
       value: /train/contacts

src/common/utils.py

@@ -30,7 +30,7 @@ AGENT_NAME = "RisingBrain Assistant"
 
 # indexes of relatedness of embedding
 COMMAND_SMS_INDEXS = [4, 5]
-
+COMMAND_BROWSER_OPEN = [10]
 
 # Twilio
 ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
@@ -46,3 +46,21 @@ def get_firebase_cred():
     else:
         cred = json.loads(FIREBASE_ENV)
         return credentials.Certificate(cred)
+
+
+class ProgramType:
+    BROWSER = "browser"
+    ALERT = "alert"
+    IMAGE = "image"
+    SMS = "sms"
+    CONTACT = "contact"
+    MESSAGE = "message"
+
+
+# validate json format
+def validateJSON(jsonData):
+    try:
+        json.loads(jsonData)
+    except ValueError as err:
+        return False
+    return True

src/rising_plugin/csv_embed.py

@@ -0,0 +1,34 @@
+import os
+
+from langchain.document_loaders.csv_loader import CSVLoader
+from langchain.embeddings.openai import OpenAIEmbeddings
+import json
+
+from ..common.utils import OPENAI_API_KEY
+
+
+def csv_embed():
+    file_path = os.path.dirname(os.path.abspath(__file__))
+    loader = CSVLoader(
+        file_path=f"{file_path}/guardrails-config/actions/phone.csv", encoding="utf8"
+    )
+    data = loader.load()
+
+    result = list()
+    for t in data:
+        query_result = get_embed(t.page_content)
+        result.append(query_result)
+    with open(f"{file_path}/guardrails-config/actions/phone.json", "w") as outfile:
+        json.dump(result, outfile, indent=2)
+
+
+"""getting embed"""
+
+
+def get_embed(data: str) -> str:
+    embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
+    return embeddings.embed_query(data)
+
+
+if __name__ == "__main__":
+    csv_embed()

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

@@ -0,0 +1,81 @@
+# SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import json
+import numpy as np
+
+from langchain.chat_models import ChatOpenAI
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.vectorstores import utils
+from langchain.document_loaders.csv_loader import CSVLoader
+from langchain.chains.question_answering import load_qa_chain
+from langchain.docstore.document import Document
+
+from src.common.utils import (
+    OPENAI_API_KEY,
+    COMMAND_SMS_INDEXS,
+    COMMAND_BROWSER_OPEN,
+)
+from src.rising_plugin.image_embedding import (
+    query_image_text,
+)
+
+from nemoguardrails.actions import action
+
+
+@action()
+async def general_question(query, model, uuid, image_search):
+    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=OPENAI_API_KEY)
+    chain = load_qa_chain(llm, chain_type="stuff")
+    file_path = os.path.dirname(os.path.abspath(__file__))
+
+    with open(f"{file_path}/phone.json", "r") as infile:
+        data = json.load(infile)
+    embeddings = OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
+
+    query_result = embeddings.embed_query(query)
+    doc_list = utils.maximal_marginal_relevance(np.array(query_result), data, k=1)
+    loader = CSVLoader(file_path=f"{file_path}/phone.csv", encoding="utf8")
+    csv_text = loader.load()
+
+    docs = []
+
+    for res in doc_list:
+        docs.append(
+            Document(
+                page_content=csv_text[res].page_content, metadata=csv_text[res].metadata
+            )
+        )
+
+    chain_data = chain.run(input_documents=docs, question=query)
+    try:
+        result = json.loads(chain_data)
+        # check image query with only its text
+        if result["program"] == "image":
+            if image_search:
+                result["content"] = json.dumps(
+                    {"image_name": query_image_text(result["content"], "", uuid)}
+                )
+            # else:
+            #     return result
+        return str(result)
+    except ValueError as e:
+        # Check sms and browser query
+        if doc_list[0] in COMMAND_SMS_INDEXS:
+            return str({"program": "sms", "content": chain_data})
+        elif doc_list[0] in COMMAND_BROWSER_OPEN:
+            return str({"program": "browser", "content": "https://google.com"})
+        return str({"program": "message", "content": chain_data})

src/rising_plugin/guardrails-config/actions/phone.csv

@@ -0,0 +1,19 @@
+prompt template
+"If user said that open a website using web browsers, please answer belowing json format. The url user is going to open can exist or not. If user doesn't say exact url and want to open some sites, you have to find the best proper url. If user didn't say any url and you can't find proper url, please set website url to ""https://www.google.com"". {""program"": ""browser"", ""url"": ""website url that user is going to open""}"
+"If user said that send notification or alert, please answer belowing json format. If user didn't say what to send, please set content to ""This is risingphone"". {""program"": ""alert"", ""content"": ""text that user is going to send""}"
+"If user is going to say about a image with its description to search, please answer belowing json format. {""program"": ""image"", ""content"": ""description of the image that user is going to search""}"
+"If user is going to ask about a image, please answer belowing json format. {""program"": ""image"", ""content"": ""description of the image that user is going to search""}"
+"If user said that send sms or text, please answer belowing json format. {""program"": ""sms"", ""content"": ""ask who""}"
+"If user said that compose, write, or create an sms message, please answer belowing json format. {""program"": ""sms"", ""content"": ""ask who""}"
+"If user said that search contact with its description such as display name or phone number, please answer belowing json format. {""program"": ""contact"", ""content"": ""description of the contact that user is going to search""}"
+"If user said that open a new tab, go to a new tab, or open a new page, please answer belowing json format. {""program"": ""open_tab"", ""content"": """"}"
+"If user said that open a new tab and search, go to a new tab and search, or open a new page and search, please answer belowing json format. {""program"": ""open_tab_search"", ""content"": ""keyword that user is going to search""}"
+"If user said that close a tab, please answer belowing json format. {""program"": ""close_tab"", ""content"": """"}"
+"If user said that launch a browser or open a browser, please answer belowing json format. {""program"": ""browser"", ""content"": ""https://google.com""}"
+"If user said that go to a previous page, or open a previous page, please answer belowing json format. {""program"": ""previous_page"", ""content"": """"}"
+"If user said that go to a next page, or open a next page, please answer belowing json format. {""program"": ""next_page"", ""content"": """"}"
+"If user said that scroll up, scroll up page, or page scroll up, please answer belowing json format. {""program"": ""scroll_up"", ""content"": """"}"
+"If user said that scroll down, scroll down page, page scroll down, please answer belowing json format. {""program"": ""scroll_down"", ""content"": """"}"
+"If user said that scroll top, scroll top page, or scroll top of page, please answer belowing json format. {""program"": ""scroll_top"", ""content"": """"}"
+"If user said that scroll bottom, scroll bottom page, or scroll bottom of page, please answer belowing json format. {""program"": ""scroll_bottom"", ""content"": """"}"
+"If all of above is not correct, please give the most appropriate answer to the user's question. Please answer belowing json format. {""program"":""message"", ""content"":""your answer""}"

src/rising_plugin/guardrails-config/config.yml

@@ -0,0 +1,25 @@
+instructions:
+  - type: general
+    content: |
+      Below is a conversation between a bot and a user about the recent job reports.
+      The bot is factual and concise. If the bot does not know the answer to a
+      question, it truthfully says it does not know.
+
+sample_conversation: |
+  user "Hello there!"
+    express greeting
+  bot express greeting
+    "Hello! How can I assist you today?"
+  user "What can you do for me?"
+    ask about capabilities
+  bot respond about capabilities
+    "I am an Rising AI assistant which helps answer questions based on a given knowledge base."
+  user "thanks"
+    express appreciation
+  bot express appreciation and offer additional help
+    "You're welcome. If you have any more questions or if there's anything else I can help you with, please don't hesitate to ask."
+
+models:
+  - type: main
+    engine: openai
+    model: text-davinci-003

src/rising_plugin/guardrails-config/general.co

@@ -0,0 +1,19 @@
+define user ask capabilities
+  "What can you do?"
+  "What can you help me with?"
+  "tell me what you can do"
+  "tell me about you"
+  "How can I use your help?"
+
+define flow
+  user ask capabilities
+  bot inform capabilities
+
+define bot inform capabilities
+  '{"program": "message", "content": "I am an Rising AI assistant which helps answer questions based on a given knowledge base."}'
+
+define flow
+  priority 0.9
+  user ...
+  $result = execute general_question(query=$last_user_message, model="gpt-3.5-turbo", uuid="", image_search=True)
+  bot $result

src/rising_plugin/guardrails-config/off-security.co

@@ -0,0 +1,18 @@
+define user ask off security
+  "Give me security information."
+  "What is password?"
+  "What is pin code?"
+  "Please let me know password."
+  "Please let me know pin."
+  "Please let me know pin code."
+  "How about pin code?"
+  "security"
+  "password"
+  "pin"
+
+define flow
+  user ask off security
+  bot explain cant off security
+
+define bot explain cant off security
+  '{"program": "message", "content": "Sorry, I cannot comment on anything which is relevant to the password or pin code."}'

src/rising_plugin/image_embedding.py

@@ -0,0 +1,62 @@
+from langchain.embeddings.openai import OpenAIEmbeddings
+
+from ..common.utils import OPENAI_API_KEY, PINECONE_NAMESPACE, PINECONE_INDEX_NAME
+from .pinecone_engine import (
+    init_pinecone,
+    get_pinecone_index_namespace,
+)
+
+
+def get_embeddings():
+    return OpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
+
+
+def embed_image_text(image_text, image_name, uuid):
+    prompt_template = f"""
+        This is the text about the image.
+        ###
+        {image_text}
+        """
+
+    embed_image_text = get_embeddings().embed_query(prompt_template)
+    index = init_pinecone(PINECONE_INDEX_NAME)
+
+    upsert_response = index.upsert(
+        vectors=[{"id": image_name, "values": embed_image_text}],
+        namespace=get_pinecone_index_namespace(uuid),
+    )
+
+    if upsert_response == 0:
+        return "fail to embed image text"
+
+    return "success to embed image text"
+
+
+def query_image_text(image_content, message, uuid):
+    embed_image_text = get_embeddings().embed_query(
+        get_prompt_image_with_message(image_content, message)
+    )
+    index = init_pinecone(PINECONE_INDEX_NAME)
+    relatedness_data = index.query(
+        vector=embed_image_text,
+        top_k=3,
+        include_values=False,
+        namespace=get_pinecone_index_namespace(uuid),
+    )
+    if len(relatedness_data["matches"]) > 0:
+        return relatedness_data["matches"][0]["id"]
+    return ""
+
+
+def get_prompt_image_with_message(image_content, message):
+    prompt_template = f"""
+                This is the text about the image.
+                ###
+                {image_content}
+                ###
+                This message is the detailed description of the image.
+                ### 
+                {message}
+                """
+
+    return prompt_template

src/rising_plugin/pinecone_engine.py

@@ -0,0 +1,84 @@
+# initialize pinecone
+import pinecone
+from typing import Any
+from ..common.utils import (
+    PINECONE_KEY,
+    PINECONE_ENV,
+    PINECONE_INDEX_NAME,
+    PINECONE_NAMESPACE,
+)
+
+DIMENSION = 1536
+METRIC = "cosine"
+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
+        )
+
+
+"""add item in pinecone"""
+
+
+def add_pinecone(namespace: str, key: str, value: str) -> Any:
+    index = init_pinecone(PINECONE_INDEX_NAME)
+
+    upsert_response = index.upsert(
+        vectors=[{"id": key, "values": value}],
+        namespace=namespace,
+    )
+    return upsert_response
+
+
+"""update item in pinecone"""
+
+
+def update_pinecone(namespace: str, key: str, value: str) -> Any:
+    index = init_pinecone(PINECONE_INDEX_NAME)
+
+    upsert_response = index.update(
+        id=key,
+        values=value,
+        namespace=namespace,
+    )
+    return upsert_response
+
+
+"""delete item in pinecone"""
+
+
+def delete_pinecone(namespace: str, key: str) -> Any:
+    index = init_pinecone(PINECONE_INDEX_NAME)
+    delete_response = index.delete(ids=[key], namespace=namespace)
+    return delete_response
+
+
+"""delete all item in the namespace"""
+
+
+def delete_all_pinecone(namespace: str) -> Any:
+    index = init_pinecone(PINECONE_INDEX_NAME)
+    delete_response = index.delete(delete_all=True, namespace=namespace)
+    return delete_response
+
+
+"""generate index name of pinecone"""
+
+
+def get_pinecone_index_name(uuid):
+    return PINECONE_INDEX_NAME + "-" + uuid
+
+
+"""generate a namespace of pinecone"""
+
+
+def get_pinecone_index_namespace(uuid):
+    return PINECONE_NAMESPACE + "-" + uuid

src/rising_plugin/risingplugin.py

@@ -0,0 +1,230 @@
+import os
+import json
+import datetime
+import openai
+import replicate
+import textwrap
+
+from typing import Any
+
+from nemoguardrails.rails import LLMRails, RailsConfig
+
+from langchain.chat_models import ChatOpenAI
+
+from firebase_admin import storage
+
+from ..common.utils import (
+    OPENAI_API_KEY,
+    FIREBASE_STORAGE_ROOT,
+)
+from .image_embedding import (
+    query_image_text,
+    get_prompt_image_with_message,
+)
+
+# Give the path to the folder containing the rails
+file_path = os.path.dirname(os.path.abspath(__file__))
+config = RailsConfig.from_path(f"{file_path}/guardrails-config")
+
+# set max_chunk_size = 1800 because of adding some string
+max_chunk_size = 1800  # recommended max_chunk_size = 2048
+
+
+def getChunks(query: str):
+    return textwrap.wrap(
+        query, width=max_chunk_size, break_long_words=False, replace_whitespace=False
+    )
+
+
+def processLargeText(app: any, chunks: any):
+    if len(chunks) == 1:
+        message = app.generate(
+            messages=[
+                {
+                    "role": "user",
+                    "content": chunks[0],
+                }
+            ]
+        )
+        response_text = ""
+        try:
+            response_text += json.loads(message["content"])["content"]
+        except Exception as e:
+            # fmt: off
+            message["content"] = message["content"].replace("\'", '"')
+            # fmt: on
+            response_text = json.loads(message["content"])
+        return response_text
+    else:
+        response_text: str = ""
+        first_query = "The total length of the content that I want to send you is too large to send in only one piece.\nFor sending you that content, I will follow this rule:\n[START PART 1/10]\nThis is the content of the part 1 out of 10 in total\n[END PART 1/10]\nThen you just answer: 'Received part 1/10'\nAnd when I tell you 'ALL PART SENT', then you can continue processing the data and answering my requests."
+        message = app.generate(messages=[{"role": "user", "content": first_query}])
+        for index, chunk in enumerate(chunks):
+            # Process each chunk with ChatGPT
+            if index + 1 != len(chunks):
+                chunk_query = (
+                    "Do not answer yet. This is just another part of the text I want to send you. Just receive and acknowledge as 'Part "
+                    + str(index + 1)
+                    + "/"
+                    + str(len(chunks))
+                    + "received' and wait for the next part.\n"
+                    + "[START PART "
+                    + str(index + 1)
+                    + "/"
+                    + str(len(chunks))
+                    + "]\n"
+                    + chunk
+                    + "\n[END PART "
+                    + str(index + 1)
+                    + "/"
+                    + str(len(chunks))
+                    + "]\n"
+                    + "Remember not answering yet. Just acknowledge you received this part with the message 'Part 1/10 received' and wait for the next part."
+                )
+                message = app.generate(
+                    messages=[
+                        {
+                            "role": "user",
+                            "content": chunk_query,
+                        }
+                    ]
+                )
+            else:
+                last_query = (
+                    "[START PART "
+                    + str(index + 1)
+                    + "/"
+                    + str(len(chunks))
+                    + chunk
+                    + "\n[END PART "
+                    + str(index + 1)
+                    + "/"
+                    + str(len(chunks))
+                    + "]\n"
+                    + "ALL PART SENT. Now you can continue processing the request."
+                )
+                message = app.generate(
+                    messages=[{"role": "user", "content": last_query}]
+                )
+                try:
+                    response_text += json.loads(message["content"])["content"]
+                except Exception as e:
+                    # fmt: off
+                    message["content"] = message["content"].replace("\'", '"')
+                    # fmt: on
+                    response_text = json.loads(message["content"])["content"]
+                program = json.loads(message["content"])["program"]
+                return {"program": program, "content": response_text}
+        # out of for-loop
+
+
+def getCompletion(
+    query,
+    model="gpt-3.5-turbo",
+    uuid="",
+    image_search=True,
+):
+    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=OPENAI_API_KEY)
+
+    # Break input text into chunks
+    chunks = getChunks(query)
+
+    app = LLMRails(config, llm)
+    return processLargeText(app, chunks)
+
+
+def query_image_ask(image_content, message, uuid):
+    prompt_template = get_prompt_image_with_message(image_content, message)
+    try:
+        data = getCompletion(query=prompt_template, uuid=uuid, image_search=False)
+        # chain_data = json.loads(data.replace("'", '"'))
+        # chain_data = json.loads(data)
+        if data["program"] == "image":
+            return True
+    except Exception as e:
+        return False
+    return False
+
+
+def getTextFromImage(filename):
+    # Create a reference to the image file you want to download
+    bucket = storage.bucket()
+    blob = bucket.blob(FIREBASE_STORAGE_ROOT.__add__(filename))
+    download_url = ""
+
+    try:
+        # Download the image to a local file
+        download_url = blob.generate_signed_url(
+            datetime.timedelta(seconds=300), method="GET", version="v4"
+        )
+
+        output = replicate.run(
+            "salesforce/blip:2e1dddc8621f72155f24cf2e0adbde548458d3cab9f00c0139eea840d0ac4746",
+            input={"image": download_url},
+        )
+
+    except Exception as e:
+        output = str("Error happend while analyzing your prompt. Please ask me again :")
+
+    return str(output)
+
+
+"""chat with ai
+response: 
+{
+ 'id': 'chatcmpl-6p9XYPYSTTRi0xEviKjjilqrWU2Ve',
+ 'object': 'chat.completion',
+ 'created': 1677649420,
+ 'model': 'gpt-3.5-turbo',
+ 'usage': {'prompt_tokens': 56, 'completion_tokens': 31, 'total_tokens': 87},
+ 'choices': [
+   {
+    'message': {
+      'role': 'assistant',
+      'content': 'The 2020 World Series was played in Arlington, Texas at the Globe Life Field, which was the new home stadium for the Texas Rangers.'},
+    'finish_reason': 'stop',
+    'index': 0
+   }
+  ]
+}
+"""
+
+
+# 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)
+    app = LLMRails(config, llm)
+
+    # split query with chunks
+    chunks = getChunks(query)
+
+    # get message from guardrails
+    message = processLargeText(app, chunks)
+
+    if (
+        message
+        == "Sorry, I cannot comment on anything which is relevant to the password or pin code."
+        or message
+        == "I am an Rising AI assistant which helps answer questions based on a given knowledge base."
+    ):
+        return message
+    else:
+        return ""
+
+
+def handle_chat_completion(messages: Any, model: str = "gpt-3.5-turbo") -> Any:
+    openai.api_key = OPENAI_API_KEY
+
+    response = openai.ChatCompletion.create(
+        model=model,
+        messages=messages,
+    )
+
+    # Filter the reply using the content filter
+    result = filter_guardrails(model, messages[-1]["content"])
+
+    if result == "":
+        return response
+    else:
+        response["choices"][0]["message"]["content"] = result
+        return response

src/router/api.py

@@ -2,18 +2,18 @@ import json
 import os
 
 from flask import Blueprint, request, jsonify, send_from_directory
-from rising_plugin.common.utils import ProgramType
 
 from src.common.assembler import Assembler
-from rising_plugin.risingplugin import (
+from src.common.utils import ProgramType
+from src.rising_plugin.risingplugin import (
     getCompletion,
     getTextFromImage,
     query_image_ask,
     handle_chat_completion,
 )
 from src.firebase.cloudmessage import send_message, get_tokens
-from rising_plugin.csv_embed import csv_embed
-from rising_plugin.image_embedding import embed_image_text, query_image_text
+from src.rising_plugin.csv_embed import csv_embed
+from src.rising_plugin.image_embedding import embed_image_text, query_image_text
 
 from src.logs import logger
 from src.model.basic_model import BasicModel
@@ -55,23 +55,19 @@ def construct_blueprint_api():
 
         # check contact querying
         try:
-            result_json = eval(result)
-            if result_json["program"] == ProgramType.CONTACT:
+            if result["program"] == ProgramType.CONTACT:
                 # querying contacts to getting its expected results
                 contacts_results = contacts_service.query_contacts(
-                    uuid=uuid, search=result_json["content"]
+                    uuid=uuid, search=result["content"]
                 )
-                result_json["content"] = str(contacts_results)
-                result = str(result_json)
+                result["content"] = str(contacts_results)
         except Exception as e:
-            logger.error(title="sendNotification", message=result)
+            logger.error(title="sendNotification", message=json.dumps(result))
 
-        notification = {"title": "alert", "content": result}
+        notification = {"title": "alert", "content": json.dumps(result)}
 
         state, value = send_message(notification, [token])
-        response = jsonify({"message": value, "result": result})
-        response.status_code = 200
-        return response
+        return assembler.to_response(200, value, result)
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
@@ -98,9 +94,7 @@ def construct_blueprint_api():
         notification = {"title": "alert", "content": embed_result}
 
         state, value = send_message(notification, [token])
-        response = jsonify({"message": value, "result": result})
-        response.status_code = 200
-        return response
+        return assembler.to_response(200, value, result)
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
@@ -138,19 +132,12 @@ def construct_blueprint_api():
 
         notification = {"title": "alert", "content": json.dumps(image_response)}
         state, value = send_message(notification, [token])
-        response = jsonify(
-            {
-                "message": value,
-                "result": json.dumps(
-                    {
-                        "program": "image",
-                        "content": json.dumps(image_response),
-                    }
-                ),
-            }
+
+        return assembler.to_response(
+            code=200,
+            message=value,
+            result={"program": "image", "content": image_response},
         )
-        response.status_code = 200
-        return response
 
     @api.route("/file/<string:filename>")
     def get_swagger_file(filename):
@@ -208,7 +195,7 @@ def construct_blueprint_api():
     @api.route("/feedback/<string:search>/<int:rating>")
     def get_feedback(search, rating):
         result = feedback_service.get(search, rating)
-        return assembler.to_response(200, "added successfully", json.dumps(result))
+        return assembler.to_response(200, "added successfully", result)
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}
@@ -218,9 +205,7 @@ def construct_blueprint_api():
     def get_commands():
         result = command_service.get()
         return assembler.to_response(
-            200,
-            "success",
-            json.dumps({"program": "help_command", "content": json.dumps(result)}),
+            200, "success", {"program": "help_command", "content": result}
         )
 
     """@generator.request_body(
@@ -268,14 +253,10 @@ def construct_blueprint_api():
         return assembler.to_response(
             200,
             "added successfully",
-            json.dumps(
-                {
-                    "program": "agent",
-                    "message": json.dumps(
-                        assistant_reply.get_one_message_item().to_json()
-                    ),
-                }
-            ),
+            {
+                "program": "agent",
+                "message": assistant_reply.get_one_message_item().to_json(),
+            },
         )
 
     """@generator.request_body(

src/service/contact_service.py

@@ -1,8 +1,8 @@
 """service to manage contacts"""
 from typing import List, Any
 
-from rising_plugin.csv_embed import get_embed
-from rising_plugin.pinecone_engine import (
+from src.rising_plugin.csv_embed import get_embed
+from src.rising_plugin.pinecone_engine import (
     get_pinecone_index_namespace,
     update_pinecone,
     init_pinecone,

src/service/llm/chat_service.py

@@ -4,7 +4,7 @@ import time
 from openai.error import RateLimitError
 
 from src.common.utils import AGENT_NAME, GPT_MODEL
-from rising_plugin.risingplugin import handle_chat_completion
+from src.rising_plugin.risingplugin import handle_chat_completion
 from src.logs import logger
 from src.model.chat_response_model import ChatResponseModel
 from src.model.message_model import MessageModel

tests/functional/test_recipes.py

@@ -1,9 +1,9 @@
 import re
 
-from rising_plugin.risingplugin import getCompletion, getTextFromImage
+from src.rising_plugin.risingplugin import getCompletion, getTextFromImage
 from src.firebase.cloudmessage import send_message
 from src.firebase.cloudmessage import get_tokens
-from rising_plugin.image_embedding import query_image_text
+from src.rising_plugin.image_embedding import query_image_text
 
 TEST_IAMGE_NAME = "0ddffe51-3763-48d9-ab74-2086de529217"
 TEST_UUID = "TEST_UUID"