feature(#8): implemented falcon model interface and http response error codes as well.

src/common/assembler.py

@@ -1,6 +1,7 @@
 # assembler to mapping data into another data type.
 from typing import Any, List
 
+from src.common.http_response_codes import responses
 from src.model.basic_model import BasicModel
 from src.model.contact_model import ContactModel
 from src.model.message_model import MessageModel
@@ -18,7 +19,7 @@ class Assembler:
     """mapping to http response"""
 
     def to_response(self, code, message, result) -> Any:
-        response = {"message": message, "result": result, "status_code": code}
+        response = {"message": responses[code], "result": result, "status_code": code}
         return response
 
     """mapping data to a collection of MessageModel"""

src/common/brain_exception.py

@@ -0,0 +1,14 @@
+"""Basic Exception in Brain"""
+from typing import Any
+
+from src.common.http_response_codes import responses
+
+
+class BrainException(Exception):
+    def __init__(self, message: str = "Exception occurred in brain"):
+        self.message = message
+        super().__init__(self.message)
+
+    def get_response_exp(self) -> Any:
+        responses[506] = ("Brain Exception", self.message)
+        return {"message": responses[506], "result": "", "status_code": 506}

src/common/http_response_codes.py

@@ -0,0 +1,52 @@
+responses = {
+    100: ("Continue", "Request received, please continue"),
+    101: ("Switching Protocols", "Switching to new protocol; obey Upgrade header"),
+    200: ("OK", "Request fulfilled, document follows"),
+    201: ("Created", "Document created, URL follows"),
+    202: ("Accepted", "Request accepted, processing continues off-line"),
+    203: ("Non-Authoritative Information", "Request fulfilled from cache"),
+    204: ("No Content", "Request fulfilled, nothing follows"),
+    205: ("Reset Content", "Clear input form for further input."),
+    206: ("Partial Content", "Partial content follows."),
+    300: ("Multiple Choices", "Object has several resources -- see URI list"),
+    301: ("Moved Permanently", "Object moved permanently -- see URI list"),
+    302: ("Found", "Object moved temporarily -- see URI list"),
+    303: ("See Other", "Object moved -- see Method and URL list"),
+    304: ("Not Modified", "Document has not changed since given time"),
+    305: (
+        "Use Proxy",
+        "You must use proxy specified in Location to access this " "resource.",
+    ),
+    307: ("Temporary Redirect", "Object moved temporarily -- see URI list"),
+    400: ("Bad Request", "Bad request syntax or unsupported method"),
+    401: ("Unauthorized", "No permission -- see authorization schemes"),
+    402: ("Payment Required", "No payment -- see charging schemes"),
+    403: ("Forbidden", "Request forbidden -- authorization will not help"),
+    404: ("Not Found", "Nothing matches the given URI"),
+    405: ("Method Not Allowed", "Specified method is invalid for this server."),
+    406: ("Not Acceptable", "URI not available in preferred format."),
+    407: (
+        "Proxy Authentication Required",
+        "You must authenticate with " "this proxy before proceeding.",
+    ),
+    408: ("Request Timeout", "Request timed out; try again later."),
+    409: ("Conflict", "Request conflict."),
+    410: ("Gone", "URI no longer exists and has been permanently removed."),
+    411: ("Length Required", "Client must specify Content-Length."),
+    412: ("Precondition Failed", "Precondition in headers is false."),
+    413: ("Request Entity Too Large", "Entity is too large."),
+    414: ("Request-URI Too Long", "URI is too long."),
+    415: ("Unsupported Media Type", "Entity body in unsupported format."),
+    416: ("Requested Range Not Satisfiable", "Cannot satisfy request range."),
+    417: ("Expectation Failed", "Expect condition could not be satisfied."),
+    500: ("Internal Server Error", "Server got itself in trouble"),
+    501: ("Not Implemented", "Server does not support this operation"),
+    502: ("Bad Gateway", "Invalid responses from another server/proxy."),
+    503: (
+        "Service Unavailable",
+        "The server cannot process the request due to a high load",
+    ),
+    504: ("Gateway Timeout", "The gateway server did not receive a timely response"),
+    505: ("HTTP Version Not Supported", "Cannot fulfill request."),
+    506: ("Brain Exception"),
+}

src/common/utils.py

@@ -35,6 +35,8 @@ COMMAND_BROWSER_OPEN = [10]
 # Twilio
 ACCOUNT_SID = os.getenv("TWILIO_ACCOUNT_SID")
 AUTH_TOKEN = os.getenv("TWILIO_AUTH_TOKEN")
+# HuggingFace
+HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
 
 
 def get_firebase_cred():

src/model/requests/request_model.py

@@ -51,6 +51,7 @@ def get_client_info(request: Request):
 class BasicReq(BaseModel):
     token: str
     uuid: str
+    model: str = "gpt-3.5-turbo"
 
 
 """endpoint: /sendNotification"""

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

@@ -17,11 +17,9 @@ 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 (
@@ -35,11 +33,19 @@ from src.rising_plugin.image_embedding import (
 
 from nemoguardrails.actions import action
 
+from src.rising_plugin.llm.falcon_llm import FalconLLM
+from src.rising_plugin.llm.gpt_llm import GptLLM
+from src.rising_plugin.llm.llms import (
+    get_llm_chain,
+    GPT_3_5_TURBO,
+    GPT_4_32K,
+    GPT_4,
+    FALCON_7B,
+)
+
 
 @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:
@@ -60,7 +66,15 @@ async def general_question(query, model, uuid, image_search):
             )
         )
 
-    chain_data = chain.run(input_documents=docs, question=query)
+    chain_data = get_llm_chain(model=model).run(input_documents=docs, question=query)
+    # test
+    if model == GPT_3_5_TURBO or model == GPT_4 or model == GPT_4_32K:
+        gpt_llm = GptLLM(model=model)
+        chain_data = gpt_llm.get_chain().run(input_documents=docs, question=query)
+    elif model == FALCON_7B:
+        falcon_llm = FalconLLM()
+        chain_data = falcon_llm.get_chain().run(input_documents=docs, question=query)
+
     try:
         result = json.loads(chain_data)
         # check image query with only its text

src/rising_plugin/llm/falcon_llm.py

@@ -0,0 +1,29 @@
+"""falcon llm"""
+from langchain import HuggingFaceHub, PromptTemplate, LLMChain
+
+from src.common.utils import HUGGINGFACEHUB_API_TOKEN
+
+repo_id = "tiiuae/falcon-7b-instruct"
+template = """
+You are an artificial intelligence assistant. The assistant gives helpful, detailed, and polite answers to the user's questions.
+
+{question}
+
+"""
+
+
+class FalconLLM:
+    def __init__(self, temperature: float = 0.6, max_new_tokens: int = 2000):
+        self.llm = HuggingFaceHub(
+            huggingfacehub_api_token=HUGGINGFACEHUB_API_TOKEN,
+            repo_id=repo_id,
+            model_kwargs={"temperature": temperature, "max_new_tokens": max_new_tokens},
+        )
+
+    def get_llm(self):
+        return self.llm
+
+    def get_chain(self):
+        prompt = PromptTemplate(template=template, input_variables=["question"])
+        llm_chain = LLMChain(prompt=prompt, llm=self.llm, verbose=True)
+        return llm_chain

src/rising_plugin/llm/gpt_llm.py

@@ -0,0 +1,26 @@
+"""gpt-open ai llm"""
+from typing import Any
+
+from langchain.chat_models import ChatOpenAI
+from langchain.chains.question_answering import load_qa_chain
+from src.common.utils import (
+    OPENAI_API_KEY,
+)
+
+
+class GptLLM:
+    def __init__(self, model: str = "gpt-3.5-turbo", temperature: float = 0.6):
+        self.llm = self.init_llm(model=model, temperature=temperature)
+
+    def init_llm(self, model: str = "gpt-3.5-turbo", temperature: float = 0.6) -> Any:
+        self.llm = ChatOpenAI(
+            model_name=model, temperature=temperature, openai_api_key=OPENAI_API_KEY
+        )
+        return self.llm
+
+    def get_llm(self):
+        return self.llm
+
+    def get_chain(self):
+        chain = load_qa_chain(self.llm, chain_type="stuff")
+        return chain

src/rising_plugin/llm/llms.py

@@ -0,0 +1,57 @@
+"""lLMs which we offer"""
+from typing import Any
+
+from src.common.brain_exception import BrainException
+from src.rising_plugin.llm.falcon_llm import FalconLLM
+from src.rising_plugin.llm.gpt_llm import GptLLM
+
+GPT_3_5_TURBO = "gpt-3.5-turbo"
+GPT_4 = "gpt-4"
+GPT_4_32K = "gpt-4-32k"
+FALCON_7B = "falcon-7b"
+
+"""list of available model we offer you"""
+LLM_MODELS = [GPT_3_5_TURBO, GPT_4, GPT_4_32K, FALCON_7B]
+
+
+"""exception message"""
+EXCEPTION_MSG = f"The model is not correct. It should be in {LLM_MODELS}"
+
+"""validate model"""
+
+
+def validate_model(model: str) -> bool:
+    if model in LLM_MODELS:
+        return True
+    return False
+
+
+"""
+Args
+model: model name of LLM such as 'gpt-3.5-turbo' | 'falcon-7b'
+Returns
+datatype: LLmChain  
+"""
+
+
+def get_llm_chain(
+    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)
+
+    return llm.get_chain()
+
+
+def get_llm(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()
+    if model == GPT_3_5_TURBO or model == GPT_4 or model == GPT_4_32K:
+        llm = GptLLM(model=model)
+    elif model == FALCON_7B:
+        llm = FalconLLM(temperature=temperature, max_new_tokens=max_new_tokens)
+    return llm

src/rising_plugin/risingplugin.py

@@ -14,6 +14,7 @@ from langchain.chat_models import ChatOpenAI
 
 from firebase_admin import storage
 
+from .llm.llms import get_llm, GPT_4, FALCON_7B
 from ..common.utils import (
     OPENAI_API_KEY,
     FIREBASE_STORAGE_ROOT,
@@ -112,12 +113,12 @@ def getCompletion(
     uuid="",
     image_search=True,
 ):
-    llm = ChatOpenAI(model_name=model, temperature=0, openai_api_key=OPENAI_API_KEY)
-
+    llm = get_llm(model=model).get_llm()
     # Break input text into chunks
     chunks = getChunks(query)
 
     app = LLMRails(config, llm)
+
     return processLargeText(app, chunks)
 
 

src/router/api.py

@@ -2,6 +2,7 @@ import json
 import os
 
 from src.common.assembler import Assembler
+from src.common.brain_exception import BrainException
 from src.common.utils import ProgramType
 from src.model.image_model import ImageModel
 from src.model.requests.request_model import (
@@ -77,13 +78,17 @@ def construct_blueprint_api() -> APIRouter:
                     uuid=uuid, search=result["content"]
                 )
                 result["content"] = str(contacts_results)
-        except Exception as e:
-            logger.error(title="sendNotification", message=json.dumps(result))
 
-        notification = {"title": "alert", "content": json.dumps(result)}
+            notification = {"title": "alert", "content": json.dumps(result)}
 
-        state, value = send_message(notification, [token])
-        return assembler.to_response(200, value, result)
+            state, value = send_message(notification, [token])
+            return assembler.to_response(200, value, result)
+        except Exception as e:
+            logger.error(
+                title="sendNotification", message="json parsing or get completion error"
+            )
+            if isinstance(e, BrainException):
+                return e.get_response_exp()
 
     """@generator.response(
         status_code=200, schema={"message": "message", "result": "test_result"}