Upload 30 files

.dockerignore

@@ -0,0 +1,29 @@
+#  Ignore node_modules
+node_modules
+
+# Ignore logs
+logs
+*.log
+
+# Ignore temporary files
+tmp
+*.tmp
+
+# Ignore build directories
+dist
+build
+
+# Ignore environment variables
+.env
+
+# Ignore Docker files
+Dockerfile
+docker-compose.yml
+
+# Ignore IDE specific files
+.vscode
+.idea
+
+# Ignore OS generated files
+.DS_Store
+Thumbs.db

.env.example

@@ -0,0 +1,22 @@
+################################################################################
+### Chat App - Back-End - GENERAL SETTINGS
+################################################################################
+
+
+#api app
+APP_HOST = 127.0.0.1
+APP_PORT = 8000
+
+################################################################################
+### LLM MODELS
+################################################################################
+
+#API token keys
+HUGGINGFACEHUB_API_TOKEN=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
+ANYSCALE_ENDPOINT_TOKEN=esecret_n1svfld85uklyx5ebaasyiw2m9
+OPENAI_API_KEY=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
+
+
+################################################################################
+### MEMORY
+################################################################################

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+faiss_embeddings_2024/index.faiss filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,135 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# testing files generated
+*.txt.json
+
+*.ipynb
+env

CHANGELOG.txt

@@ -0,0 +1,2 @@
+2023-11-30 pipeline with only document retrieval
+2024-08-23 azure app serice , open ai 'gpt4o mini'

Dockerfile

@@ -0,0 +1,42 @@
+# Step 1: Use Python 3.11.9 as required
+FROM python:3.11.9
+
+# Step 2: Set up environment variables and timezone configuration
+ENV TZ=Asia/Colombo
+RUN apt-get update && apt-get install -y libaio1 wget unzip tzdata \
+    && ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
+
+# Step 4: Add a user for running the app (after installations)
+RUN useradd -m -u 1000 user
+
+# Step 5: Create the /app directory and set ownership to the new user
+RUN mkdir -p /app && chown -R user:user /app
+
+# Step 6: Switch to non-root user after the directory has the right permissions
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Step 7: Set up the working directory for the app
+WORKDIR /app
+
+# Step 8: Copy the requirements file and install dependencies
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Step 9: Install pipenv and handle pipenv environment
+RUN pip install pipenv
+COPY --chown=user . /app
+RUN pipenv install
+
+# Step 10: Expose the necessary port (7860 for Hugging Face Spaces)
+EXPOSE 7860
+
+# Step 11: Set environment variables for the app
+ENV APP_HOST=0.0.0.0 
+ENV APP_PORT=7860
+
+# Step 12: Create logs directory (if necessary)
+RUN mkdir -p /app/logs
+
+# Step 13: Run the app using Uvicorn, listening on port 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,22 @@
+License
+
+Copyright (2024-2025) AI Labs, IronOne Technologies, LLC
+All Rights Reserved
+
+This source code is protected under international copyright law.  All rights
+reserved and protected by the copyright holders.
+This file is confidential and only available to authorized individuals with the
+permission of the copyright holders.
+
+Permission is hereby granted, to  {User}. for testing and development purposes.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,11 +1,14 @@
----
-title: RegGPT Back End D
-emoji: 📉
-colorFrom: purple
-colorTo: blue
-sdk: docker
-pinned: false
-short_description: IronOne-AI-Labs/RegGPT-Back-End
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Boardpac Chat App Test Streamlit
+emoji: 🏃
+colorFrom: gray
+colorTo: yellow
+sdk: streamlit
+sdk_version: 1.39.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: chatbot on central bank regulations
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

config.py

@@ -0,0 +1,36 @@
+AVALIABLE_MODELS=[
+    {
+    "id":"gpt-4o-mini",
+    "model_name":"openai/gpt-4o-mini",
+    "description":"gpt-4o-mini model from openai"
+    }
+]
+
+MODELS={
+    "DEFAULT":"openai",
+    "gpt-4o-mini":"openai",
+    
+}
+
+DATASETS={
+    "DEFAULT":"faiss",
+    "a":"A",
+    "b":"B",
+    "c":"C"
+
+}
+
+MEMORY_WINDOW_K = 1
+
+QA_MODEL_TYPE = "openai"
+GENERAL_QA_MODEL_TYPE = "openai"
+ROUTER_MODEL_TYPE = "openai"
+Multi_Query_MODEL_TYPE = "openai"
+
+
+ANSWER_TYPES = [
+    "relevant",
+    "greeting",
+    "other",
+    "not sure",
+]

configs/__init__.py

@@ -0,0 +1,5 @@
+# import os
+# import sys
+
+# if os.path.dirname(os.path.abspath(__file__)) not in sys.path:
+#     sys.path.append(os.path.dirname(os.path.abspath(__file__)))

configs/logger.py

@@ -0,0 +1,40 @@
+import logging
+import time
+# from functools import wraps
+
+logger = logging.getLogger(__name__)
+
+stream_handler = logging.StreamHandler()
+log_filename = "output.log"
+file_handler = logging.FileHandler(filename=log_filename)
+handlers = [stream_handler, file_handler]
+
+
+class TimeFilter(logging.Filter):
+    def filter(self, record):
+        return "Running" in record.getMessage()
+
+
+logger.addFilter(TimeFilter())
+
+# Configure the logging module
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(name)s %(asctime)s - %(levelname)s - %(message)s",
+    handlers=handlers,
+)
+
+
+def time_logger(func):
+    """Decorator function to log time taken by any function."""
+
+    # @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()  # Start time before function execution
+        result = func(*args, **kwargs)  # Function execution
+        end_time = time.time()  # End time after function execution
+        execution_time = end_time - start_time  # Calculate execution time
+        logger.info(f"Running {func.__name__}: --- {execution_time} seconds ---")
+        return result
+
+    return wrapper

controller.py

@@ -0,0 +1,44 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+import logging
+logger = logging.getLogger(__name__)
+from config import AVALIABLE_MODELS , MEMORY_WINDOW_K
+
+# from qaPipeline import QAPipeline
+# from qaPipeline_retriever_only import QAPipeline
+# qaPipeline = QAPipeline()
+
+from qaPipeline import run_agent
+
+def get_QA_Answers(userQuery):
+    # model=userQuery.model
+    query=userQuery.content
+
+    # chat_history = userQuery.chat_history[-MEMORY_WINDOW_K:]
+    
+    # logger.info(f"model: {model} \n query : {query} \n chat_history : {chat_history}")
+    logger.info(f"query : {query}")
+    # answer= run_agent(query=query, model=model, chat_history=chat_history)
+    answer= run_agent(query=query)
+    logger.info(f"Response: {answer}")
+    return answer
+
+
+def get_avaliable_models():
+    logger.info("getting avaliable models")
+    return AVALIABLE_MODELS
+

conversationBufferWindowMemory.py

@@ -0,0 +1,134 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/11/2020
+ *************************************************************************/
+ """
+
+from abc import ABC
+from typing import Any, Dict, Optional, Tuple
+# import json
+
+from langchain.memory.chat_message_histories.in_memory import ChatMessageHistory
+from langchain.memory.utils import get_prompt_input_key
+from langchain.pydantic_v1 import Field
+from langchain.schema import BaseChatMessageHistory, BaseMemory
+
+from typing import List, Union
+
+# from langchain.memory.chat_memory import BaseChatMemory
+from langchain.schema.messages import BaseMessage, get_buffer_string
+
+
+class BaseChatMemory(BaseMemory, ABC):
+    """Abstract base class for chat memory."""
+
+    chat_memory: BaseChatMessageHistory = Field(default_factory=ChatMessageHistory)
+    output_key: Optional[str] = None
+    input_key: Optional[str] = None
+    return_messages: bool = False
+
+    def _get_input_output(
+        self, inputs: Dict[str, Any], outputs: Dict[str, str]
+    ) -> Tuple[str, str]:
+        
+
+        if self.input_key is None:
+            prompt_input_key = get_prompt_input_key(inputs, self.memory_variables)
+        else:
+            prompt_input_key = self.input_key
+
+        if self.output_key is None:
+            """
+            output for agent with LLM chain tool                     = {answer} 
+            output for agent with ConversationalRetrievalChain tool  = {'question', 'chat_history', 'answer','source_documents'}
+            """
+        
+            LLM_key = 'output'
+            Retrieval_key = 'answer'
+            if isinstance(outputs[LLM_key], dict):
+                Retrieval_dict = outputs[LLM_key]
+                if Retrieval_key in Retrieval_dict.keys():
+                    #output keys are 'answer' , 'source_documents'
+                    output = Retrieval_dict[Retrieval_key]
+                else:
+                    raise ValueError(f"output key: {LLM_key} not a valid dictionary")
+
+            else:
+                #otherwise output key will be 'output'
+                output_key = list(outputs.keys())[0]
+                output = outputs[output_key]
+
+            # if len(outputs) != 1:
+            #     raise ValueError(f"One output key expected, got {outputs.keys()}")
+                
+            
+        else:
+            output_key = self.output_key
+            output = outputs[output_key]
+
+        return inputs[prompt_input_key], output
+
+    def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
+        """Save context from this conversation to buffer."""
+        input_str, output_str = self._get_input_output(inputs, outputs)
+        self.chat_memory.add_user_message(input_str)
+        self.chat_memory.add_ai_message(output_str)
+
+    def clear(self) -> None:
+        """Clear memory contents."""
+        self.chat_memory.clear()
+
+
+
+
+
+class ConversationBufferWindowMemory(BaseChatMemory):
+    """Buffer for storing conversation memory inside a limited size window."""
+
+    human_prefix: str = "Human"
+    ai_prefix: str = "AI"
+    memory_key: str = "history"  #: :meta private:
+    k: int = 5
+    """Number of messages to store in buffer."""
+
+    @property
+    def buffer(self) -> Union[str, List[BaseMessage]]:
+        """String buffer of memory."""
+        return self.buffer_as_messages if self.return_messages else self.buffer_as_str
+
+    @property
+    def buffer_as_str(self) -> str:
+        """Exposes the buffer as a string in case return_messages is True."""
+        messages = self.chat_memory.messages[-self.k * 2 :] if self.k > 0 else []
+        return get_buffer_string(
+            messages,
+            human_prefix=self.human_prefix,
+            ai_prefix=self.ai_prefix,
+        )
+
+    @property
+    def buffer_as_messages(self) -> List[BaseMessage]:
+        """Exposes the buffer as a list of messages in case return_messages is False."""
+        return self.chat_memory.messages[-self.k * 2 :] if self.k > 0 else []
+
+    @property
+    def memory_variables(self) -> List[str]:
+        """Will always return list of memory variables.
+
+        :meta private:
+        """
+        return [self.memory_key]
+
+    def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Return history buffer."""
+        return {self.memory_key: self.buffer}

data/__init__.py

@@ -0,0 +1,5 @@
+# import os
+# import sys
+
+# if os.path.dirname(os.path.abspath(__file__)) not in sys.path:
+#     sys.path.append(os.path.dirname(os.path.abspath(__file__)))

ensemble_retriever.py

@@ -0,0 +1,228 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+"""
+Ensemble retriever that ensemble the results of 
+multiple retrievers by using weighted  Reciprocal Rank Fusion
+"""
+
+import os
+import sys
+
+from pathlib import Path
+Path(__file__).resolve().parent.parent
+
+if os.path.dirname(os.path.abspath(__file__)) not in sys.path:
+    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+
+import logging
+logger = logging.getLogger(__name__)
+from typing import Any, Dict, List
+
+from langchain.callbacks.manager import (
+    AsyncCallbackManagerForRetrieverRun,
+    CallbackManagerForRetrieverRun,
+)
+from langchain.pydantic_v1 import root_validator
+from langchain.schema import BaseRetriever, Document
+
+import numpy as np
+import pandas as pd
+
+
+class EnsembleRetriever(BaseRetriever):
+    """Retriever that ensembles the multiple retrievers.
+
+    It uses a rank fusion.
+
+    Args:
+        retrievers: A list of retrievers to ensemble.
+        weights: A list of weights corresponding to the retrievers. Defaults to equal
+            weighting for all retrievers.
+        c: A constant added to the rank, controlling the balance between the importance
+            of high-ranked items and the consideration given to lower-ranked items.
+            Default is 60.
+    """
+
+    retrievers: List[BaseRetriever]
+    weights: List[float]
+    c: int = 60
+    date_key: str = "year"
+    top_k: int = 4
+
+    @root_validator(pre=True,allow_reuse=True)
+    def set_weights(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        if not values.get("weights"):
+            n_retrievers = len(values["retrievers"])
+            values["weights"] = [1 / n_retrievers] * n_retrievers
+        return values
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
+    ) -> List[Document]:
+        """
+        Get the relevant documents for a given query.
+
+        Args:
+            query: The query to search for.
+
+        Returns:
+            A list of reranked documents.
+        """
+
+        # Get fused result of the retrievers.
+        fused_documents = self.rank_fusion(query, run_manager)
+
+        # check for key exists
+        if fused_documents[0].metadata[self.date_key] != None:
+            doc_dates = pd.to_datetime(
+                [doc.metadata[self.date_key] for doc in fused_documents]
+            )
+            sorted_node_idxs = np.flip(doc_dates.argsort())
+            fused_documents = [fused_documents[idx] for idx in sorted_node_idxs]
+            logger.info('Ensemble Retriever Documents sorted by year')
+
+        # return fused_documents[:self.top_k]
+        return fused_documents
+
+    async def _aget_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: AsyncCallbackManagerForRetrieverRun,
+    ) -> List[Document]:
+        """
+        Asynchronously get the relevant documents for a given query.
+
+        Args:
+            query: The query to search for.
+
+        Returns:
+            A list of reranked documents.
+        """
+
+        # Get fused result of the retrievers.
+        fused_documents = await self.arank_fusion(query, run_manager)
+
+        return fused_documents
+
+    def rank_fusion(
+        self, query: str, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """
+        Retrieve the results of the retrievers and use rank_fusion_func to get
+        the final result.
+
+        Args:
+            query: The query to search for.
+
+        Returns:
+            A list of reranked documents.
+        """
+
+        # Get the results of all retrievers.
+        retriever_docs = [
+            retriever.get_relevant_documents(
+                query, callbacks=run_manager.get_child(tag=f"retriever_{i+1}")
+            )
+            for i, retriever in enumerate(self.retrievers)
+        ]
+
+        # apply rank fusion
+        fused_documents = self.weighted_reciprocal_rank(retriever_docs)
+
+        return fused_documents
+
+    async def arank_fusion(
+        self, query: str, run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """
+        Asynchronously retrieve the results of the retrievers
+        and use rank_fusion_func to get the final result.
+
+        Args:
+            query: The query to search for.
+
+        Returns:
+            A list of reranked documents.
+        """
+
+        # Get the results of all retrievers.
+        retriever_docs = [
+            await retriever.aget_relevant_documents(
+                query, callbacks=run_manager.get_child(tag=f"retriever_{i+1}")
+            )
+            for i, retriever in enumerate(self.retrievers)
+        ]
+
+        # apply rank fusion
+        fused_documents = self.weighted_reciprocal_rank(retriever_docs)
+
+        return fused_documents
+
+    def weighted_reciprocal_rank(
+        self, doc_lists: List[List[Document]]
+    ) -> List[Document]:
+        """
+        Perform weighted Reciprocal Rank Fusion on multiple rank lists.
+        You can find more details about RRF here:
+        https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf
+
+        Args:
+            doc_lists: A list of rank lists, where each rank list contains unique items.
+
+        Returns:
+            list: The final aggregated list of items sorted by their weighted RRF
+                    scores in descending order.
+        """
+        if len(doc_lists) != len(self.weights):
+            raise ValueError(
+                "Number of rank lists must be equal to the number of weights."
+            )
+
+        # Create a union of all unique documents in the input doc_lists
+        all_documents = set()
+        for doc_list in doc_lists:
+            for doc in doc_list:
+                all_documents.add(doc.page_content)
+
+        # Initialize the RRF score dictionary for each document
+        rrf_score_dic = {doc: 0.0 for doc in all_documents}
+
+        # Calculate RRF scores for each document
+        for doc_list, weight in zip(doc_lists, self.weights):
+            for rank, doc in enumerate(doc_list, start=1):
+                rrf_score = weight * (1 / (rank + self.c))
+                rrf_score_dic[doc.page_content] += rrf_score
+
+        # Sort documents by their RRF scores in descending order
+        sorted_documents = sorted(
+            rrf_score_dic.keys(), key=lambda x: rrf_score_dic[x], reverse=True
+        )
+
+        # Map the sorted page_content back to the original document objects
+        page_content_to_doc_map = {
+            doc.page_content: doc for doc_list in doc_lists for doc in doc_list
+        }
+        sorted_docs = [
+            page_content_to_doc_map[page_content] for page_content in sorted_documents
+        ]
+
+        return sorted_docs

faissDb.py

@@ -0,0 +1,68 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 14/03/2024
+ *************************************************************************/
+"""
+
+import logging
+logger = logging.getLogger(__name__)
+import os
+from dotenv import load_dotenv
+
+# from langchain_text_splitters import RecursiveCharacterTextSplitter
+# from langchain.docstore.document import Document
+# from langchain_community.document_loaders import PyPDFLoader
+# from langchain.document_loaders import TextLoader
+# from langchain_community.document_loaders import DirectoryLoader
+from langchain_community.vectorstores import FAISS
+
+
+chunk_size=2000
+chunk_overlap=100
+
+embeddings_model_name = "BAAI/bge-large-en-v1.5"
+persist_directory = "faiss_embeddings_2024"
+
+from langchain_community.embeddings import HuggingFaceEmbeddings
+embeddings = HuggingFaceEmbeddings(model_name=embeddings_model_name)
+print(f"> Local Embeddings loading")
+
+load_dotenv()
+
+# from langchain_community.embeddings import HuggingFaceInferenceAPIEmbeddings
+# inference_api_key = os.environ.get('HUGGINGFACEHUB_API_TOKEN')
+# embeddings = HuggingFaceInferenceAPIEmbeddings(
+#     api_key=inference_api_key, model_name=embeddings_model_name
+# )
+# print(f"> HuggingFace InferenceAPI Embeddings loading")
+# print(f"> --- ---- ---- HuggingFace api key: {inference_api_key}")
+
+
+# def create_faiss():
+#     # documents = DirectoryLoader(persist_directory,  loader_cls=PyMuPDFLoader).load()
+#     documents = DirectoryLoader("CBSL",  loader_cls=PyPDFLoader).load()
+    
+#     text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+#     texts = text_splitter.split_documents(documents)
+#     vectorstore = FAISS.from_documents(texts, embeddings)
+#     vectorstore.save_local("faiss_index")
+
+
+def load_FAISS_store():
+    try:
+        print(f"> {persist_directory} loading")
+        logger.info(f"{persist_directory} loaded")
+        return FAISS.load_local(persist_directory, embeddings, allow_dangerous_deserialization=True)
+    except Exception as e:
+        logger.exception(e)
+        raise e

faiss_embeddings_2024/index.faiss

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3087f02172887cbf8bfb0fb3b371843548619c2a2873fdf4629339e2031a2c1
+size 10895405

faiss_embeddings_2024/index.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3da917c3758e2bfe0aedbd050199f4c80ec372d5b0349b49126b790fb1757db9
+size 3935715

llm.py

@@ -0,0 +1,47 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+import os
+# import time
+import logging
+logger = logging.getLogger(__name__)
+from dotenv import load_dotenv
+
+# from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+from langchain_openai import ChatOpenAI
+
+load_dotenv()
+
+openai_api_key = os.environ.get('OPENAI_API_KEY')
+# openai_api_key = "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"
+print(f"--- ---- ---- openai_api_key: {openai_api_key}")
+
+verbose = os.environ.get('VERBOSE')
+
+def get_model(model_type):
+   
+    match model_type:
+        case "openai":
+            llm = ChatOpenAI(model_name="gpt-4o-mini", temperature=0, openai_api_key=openai_api_key)
+        case _default:
+            # raise exception if model_type is not supported
+            msg=f"Model type '{model_type}' is not supported. Please choose a valid one"
+            logger.error(msg)
+            return Exception(msg)
+
+
+    logger.info(f"model_type: {model_type} loaded:")
+    return llm

llmChain.py

@@ -0,0 +1,96 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+import os
+import logging
+logger = logging.getLogger(__name__)
+from dotenv import load_dotenv
+
+load_dotenv()
+
+verbose = os.environ.get('VERBOSE')
+
+from llm import get_model
+from langchain.chains import  ConversationalRetrievalChain
+# from conversationBufferWindowMemory import ConversationBufferWindowMemory
+
+# from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+from prompts import retrieval_qa_chain_prompt, document_combine_prompt, general_qa_chain_prompt, router_prompt
+
+def get_qa_chain(model_type,retriever):
+    logger.info("creating qa_chain")
+    
+    try:
+        qa_llm = get_model(model_type)
+
+        qa_chain = ConversationalRetrievalChain.from_llm(
+            llm=qa_llm,
+            chain_type="stuff",
+            retriever = retriever, 
+            # retriever = self.retriever(search_kwargs={"k": target_source_chunks}
+            return_source_documents= True,
+            get_chat_history=lambda h : h,
+            combine_docs_chain_kwargs={
+                "prompt": retrieval_qa_chain_prompt,
+                "document_prompt": document_combine_prompt,
+            },
+            verbose=True,
+            # memory=memory,
+        )
+
+        logger.info("qa_chain created")
+        return qa_chain
+
+    except Exception as e:
+        msg=f"Error : {e}"
+        logger.exception(msg)
+        raise e
+
+
+def get_general_qa_chain(model_type):
+    logger.info("creating general_qa_chain")
+    
+    try:
+        general_qa_llm = get_model(model_type)
+        general_qa_chain = LLMChain(llm=general_qa_llm, prompt=general_qa_chain_prompt)
+
+        logger.info("general_qa_chain created")
+        return general_qa_chain
+
+    except Exception as e:
+        msg=f"Error : {e}"
+        logger.exception(msg)
+        raise e
+
+
+def get_router_chain(model_type):
+    logger.info("creating router_chain")
+    
+    try:
+        router_llm = get_model(model_type)
+        router_chain = LLMChain(llm=router_llm, prompt=router_prompt)
+
+        logger.info("router_chain created")
+        return router_chain
+
+    except Exception as e:
+        msg=f"Error : {e}"
+        logger.exception(msg)
+        raise e
+
+

multi_query_retriever.py

@@ -0,0 +1,254 @@
+
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 21/03/2024
+ *************************************************************************/
+"""
+
+import asyncio
+import logging
+from typing import List, Optional, Sequence
+
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForRetrieverRun,
+    CallbackManagerForRetrieverRun,
+)
+from langchain_core.documents import Document
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.output_parsers import BaseOutputParser
+from langchain_core.prompts.prompt import PromptTemplate
+from langchain_core.retrievers import BaseRetriever
+
+from langchain.chains.llm import LLMChain
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+from prompts import MULTY_QUERY_PROMPT
+
+class LineListOutputParser(BaseOutputParser[List[str]]):
+    """Output parser for a list of lines."""
+
+    def parse(self, text: str) -> List[str]:
+        lines = text.strip().split("\n")
+        return lines
+
+
+# Default prompt
+# DEFAULT_QUERY_PROMPT = PromptTemplate(
+#     input_variables=["question"],
+#     template="""You are an AI language model assistant. Your task is 
+#     to generate 3 different versions of the given user 
+#     question to retrieve relevant documents from a vector  database. 
+#     By generating multiple perspectives on the user question, 
+#     your goal is to help the user overcome some of the limitations 
+#     of distance-based similarity search. Provide these alternative 
+#     questions separated by newlines. Original question: {question}""",
+# )
+
+
+
+
+def _unique_documents(documents: Sequence[Document]) -> List[Document]:
+    return [doc for i, doc in enumerate(documents) if doc not in documents[:i]]
+
+
+class MultiQueryRetriever(BaseRetriever):
+    """Given a query, use an LLM to write a set of queries.
+
+    Retrieve docs for each query. Return the unique union of all retrieved docs.
+    """
+
+    retriever: BaseRetriever
+    llm_chain: LLMChain
+    verbose: bool = True
+    parser_key: str = "lines"
+    """DEPRECATED. parser_key is no longer used and should not be specified."""
+    include_original: bool = False
+    """Whether to include the original query in the list of generated queries."""
+    date_key: str = "year"
+    top_k: int = 4
+
+    @classmethod
+    def from_llm(
+        cls,
+        retriever: BaseRetriever,
+        llm: BaseLanguageModel,
+        prompt: PromptTemplate = MULTY_QUERY_PROMPT,
+        parser_key: Optional[str] = None,
+        include_original: bool = False,
+    ) -> "MultiQueryRetriever":
+        """Initialize from llm using default template.
+
+        Args:
+            retriever: retriever to query documents from
+            llm: llm for query generation using DEFAULT_QUERY_PROMPT
+            include_original: Whether to include the original query in the list of
+                generated queries.
+
+        Returns:
+            MultiQueryRetriever
+        """
+        output_parser = LineListOutputParser()
+        llm_chain = LLMChain(llm=llm, prompt=prompt, output_parser=output_parser)
+        return cls(
+            retriever=retriever,
+            llm_chain=llm_chain,
+            include_original=include_original,
+        )
+
+    async def _aget_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: AsyncCallbackManagerForRetrieverRun,
+    ) -> List[Document]:
+        """Get relevant documents given a user query.
+
+        Args:
+            question: user query
+
+        Returns:
+            Unique union of relevant documents from all generated queries
+        """
+        queries = await self.agenerate_queries(query, run_manager)
+        if self.include_original:
+            queries.append(query)
+        documents = await self.aretrieve_documents(queries, run_manager)
+        return self.unique_union(documents)
+
+
+    async def agenerate_queries(
+        self, question: str, run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> List[str]:
+        """Generate queries based upon user input.
+
+        Args:
+            question: user query
+
+        Returns:
+            List of LLM generated queries that are similar to the user input
+        """
+        response = await self.llm_chain.ainvoke(
+            inputs={"question": question}, callbacks=run_manager.get_child()
+        )
+        lines = response["text"]
+        if self.verbose:
+            logger.info(f"Generated queries: {lines}")
+        return lines
+
+    async def aretrieve_documents(
+        self, queries: List[str], run_manager: AsyncCallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """Run all LLM generated queries.
+
+        Args:
+            queries: query list
+
+        Returns:
+            List of retrieved Documents
+        """
+        document_lists = await asyncio.gather(
+            *(
+                self.retriever.aget_relevant_documents(
+                    query, callbacks=run_manager.get_child()
+                )
+                for query in queries
+            )
+        )
+        return [doc for docs in document_lists for doc in docs]
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: CallbackManagerForRetrieverRun,
+    ) -> List[Document]:
+        """Get relevant documents given a user query.
+
+        Args:
+            question: user query
+
+        Returns:
+            Unique union of relevant documents from all generated queries
+        """
+        queries = self.generate_queries(query, run_manager)
+        if self.include_original:
+            queries.append(query)
+        documents = self.retrieve_documents(queries, run_manager)
+        fused_documents= self.unique_union(documents)
+        # check for key exists
+        if fused_documents[0].metadata[self.date_key] != None:
+            doc_dates = pd.to_datetime(
+                [doc.metadata[self.date_key] for doc in fused_documents]
+            )
+            sorted_node_idxs = np.flip(doc_dates.argsort())
+            fused_documents = [fused_documents[idx] for idx in sorted_node_idxs]
+            logger.info('Documents sorted by year')
+
+        return fused_documents[:self.top_k]
+    
+
+
+    def generate_queries(
+        self, question: str, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[str]:
+        """Generate queries based upon user input.
+
+        Args:
+            question: user query
+
+        Returns:
+            List of LLM generated queries that are similar to the user input
+        """
+        response = self.llm_chain.invoke(
+            {"question": question}, callbacks=run_manager.get_child()
+        )
+        lines = response["text"]
+        if self.verbose:
+            logger.info(f"Generated queries: {lines}")
+        return lines
+
+    def retrieve_documents(
+        self, queries: List[str], run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        """Run all LLM generated queries.
+
+        Args:
+            queries: query list
+
+        Returns:
+            List of retrieved Documents
+        """
+        documents = []
+        for query in queries:
+            logger.info(f"MQ Retriever question: {query}")
+            docs = self.retriever.get_relevant_documents(
+                query, callbacks=run_manager.get_child()
+            )
+            documents.extend(docs)
+        return documents
+
+    def unique_union(self, documents: List[Document]) -> List[Document]:
+        """Get unique Documents.
+
+        Args:
+            documents: List of retrieved Documents
+
+        Returns:
+            List of unique retrieved Documents
+        """
+        return _unique_documents(documents)
+    

output_parser.py

@@ -0,0 +1,39 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+def qa_chain_output_parser(result):
+    return {
+        "question": result["question"], 
+        "answer": result["answer"],
+        "source_documents": result["source_documents"]
+    }
+
+def general_qa_chain_output_parser(result):
+    return {
+        "question": result["question"], 
+        "answer": result["text"],
+        "source_documents": []
+    }
+
+
+def out_of_domain_chain_parser(query):
+    return {
+        "question": query, 
+        "answer":"sorry this question is out of my domain.",
+        "source_documents":[]
+    }
+
+

prompts.py

@@ -0,0 +1,123 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2024-2025) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 19/03/2024
+ *************************************************************************/
+"""
+
+from langchain.prompts import PromptTemplate
+
+# multi query prompt
+MULTY_QUERY_PROMPT = PromptTemplate(
+    input_variables=["question"],
+    template="""You are an AI language model assistant. Your task is to generate three 
+    different versions of the given user question to retrieve relevant documents from a vector 
+    database. By generating multiple perspectives on the user question, your goal is to help
+    the user overcome some of the limitations of the distance-based similarity search. 
+    Provide these alternative questions separated by newlines.
+
+    Dont add anything extra before or after to the 3 questions. Just give 3 lines with 3 questions.
+    Just provide 3 lines having 3 questions only.
+    Answer should be in following format.
+
+    1. alternative question 1
+    2. alternative question 2
+    3. alternative question 3
+
+    Original question: {question}""",
+)
+
+#retrieval prompt
+B_INST, E_INST = "[INST]", "[/INST]"
+B_SYS, E_SYS = "<<SYS>>\n", "\n<</SYS>>\n\n"
+
+retrieval_qa_template = (
+"""<<SYS>>
+You are the AI assistant of company 'boardpac' which provide services to company board members related to banking and financial sector.
+
+please answer the question based on the chat history provided below.  Answer should be short and simple as possible and on to the point.
+<chat history>: {chat_history}
+
+If the  question is related to welcomes and greetings answer accordingly.
+
+Else If the question is related to Banking and Financial Services Sector like Banking & Financial regulations, legal framework, governance framework, compliance requirements as per Central Bank regulations.
+please answer the question based only on the information provided in following central bank documents published in various years.
+The published year is mentioned as the  metadata 'year' of each source document.
+Please notice that content of a one document of a past year can updated by a new document from a recent year.
+Always try to answer with latest information and mention the year which information extracted.
+If you dont know the answer say you dont know, dont try to makeup answers. Dont add any extra details that is not mentioned in the context.
+
+<</SYS>>
+
+[INST]
+<DOCUMENTS>
+{context}
+</DOCUMENTS>
+
+Question : {question}[/INST]"""
+)
+
+
+retrieval_qa_chain_prompt = PromptTemplate(
+    input_variables=["question", "context", "chat_history"], 
+    template=retrieval_qa_template
+)
+
+
+
+#document combine prompt
+document_combine_prompt = PromptTemplate(
+    input_variables=["source","year", "page","page_content"],
+    template= 
+    """<doc> source: {source}, year: {year}, page: {page}, page content: {page_content} </doc>"""
+)
+
+
+router_template_Mixtral_V0= """
+You are the AI assistant of company 'boardpac' which provide services to company board members related to banking and financial sector.
+
+If a user asks a question you have to classify it to following 3 types Relevant, Greeting, Other.
+ 
+"Relevant”: If the question is related to Banking and Financial Services Sector like Banking & Financial regulations, legal framework, governance framework, compliance requirements as per Central Bank regulations.
+"Greeting”: If the question is a greeting like good morning, hi my name is., thank you or General Question ask about the AI assistance of a company boardpac.
+"Other”: If the question is not related to research papers.
+ 
+Give the correct name of question type. If you are not sure return "Not Sure" instead.
+ 
+Question : {question}
+"""
+router_prompt=PromptTemplate.from_template(router_template_Mixtral_V0)
+
+
+general_qa_template_Mixtral_V0= """
+You are the AI assistant of company 'boardpac' which provide services to company board members related to banking and financial sector.
+you can answer Banking and Financial Services Sector like Banking & Financial regulations, legal framework, governance framework, compliance requirements as per Central Bank regulations related question .
+
+Is the provided question below a greeting? First, evaluate whether the input resembles a typical greeting or not.
+
+Greetings are used to say 'hello' and 'how are you?' and to say 'goodbye' and 'nice speaking with you.' and 'hi, I'm (user's name).'
+Greetings are words used when we want to introduce ourselves to others and when we want to find out how someone is feeling.
+
+You can only reply to the user's greetings. 
+If the question is a greeting, reply accordingly as the AI assistant of company boardpac. 
+If the question is not related to greetings and research papers, say that it is out of your domain.
+If the question is not clear enough, ask for more details and don't try to make up answers.
+
+Answer should be polite, short, and simple.
+
+Additionally, it's important to note that this AI assistant has access to an internal collection of research papers, and answers can be provided using the information available in those CBSL Dataset.
+
+Question: {question}
+"""
+
+general_qa_chain_prompt = PromptTemplate.from_template(general_qa_template_Mixtral_V0)
+

qaPipeline.py

@@ -0,0 +1,150 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 18/03/2024
+ *************************************************************************/
+ """
+
+import os
+import time
+import logging
+logger = logging.getLogger(__name__)
+from dotenv import load_dotenv
+from fastapi import HTTPException
+from llmChain import get_qa_chain, get_general_qa_chain, get_router_chain
+from output_parser import general_qa_chain_output_parser, qa_chain_output_parser, out_of_domain_chain_parser
+
+from config import QA_MODEL_TYPE, GENERAL_QA_MODEL_TYPE, ROUTER_MODEL_TYPE, Multi_Query_MODEL_TYPE
+from retriever import load_faiss_retriever, load_ensemble_retriever, load_multi_query_retriever
+load_dotenv()
+
+verbose = os.environ.get('VERBOSE')
+
+qa_model_type=QA_MODEL_TYPE
+general_qa_model_type=GENERAL_QA_MODEL_TYPE
+router_model_type=ROUTER_MODEL_TYPE #"google/flan-t5-xxl"
+multi_query_model_type=Multi_Query_MODEL_TYPE #"google/flan-t5-xxl"
+# model_type="tiiuae/falcon-7b-instruct"
+
+# retriever=load_faiss_retriever()
+retriever=load_ensemble_retriever()
+# retriever=load_multi_query_retriever(multi_query_model_type)
+logger.info("retriever loaded:")
+
+qa_chain= get_qa_chain(qa_model_type,retriever)
+general_qa_chain= get_general_qa_chain(general_qa_model_type)
+router_chain= get_router_chain(router_model_type)
+
+def chain_selector(chain_type, query):
+    chain_type = chain_type.lower().strip()
+    logger.info(f"chain_selector : chain_type: {chain_type} Question: {query}")
+    if "greeting" in chain_type:
+        return run_general_qa_chain(query)
+    elif "other" in chain_type:
+        return run_out_of_domain_chain(query)
+    elif ("relevant" in chain_type) or ("not sure" in chain_type) :
+        return run_qa_chain(query)
+    else:
+        raise ValueError(
+            f"Received invalid type '{chain_type}'"
+        )
+    
+def run_agent(query):
+    try:
+        logger.info(f"run_agent : Question: {query}")
+        print(f"---------------- run_agent : Question: {query} ----------------")
+        # Get the answer from the chain
+        start = time.time()
+        chain_type = run_router_chain(query)
+        res = chain_selector(chain_type,query)
+        end = time.time()
+
+        # log the result
+        logger.error(f"---------------- Answer (took {round(end - start, 2)} s.) \n: {res}")
+        print(f" \n ---------------- Answer (took {round(end - start, 2)} s.): --------------  \n")
+
+        return res
+    
+    except HTTPException as e:
+            print('HTTPException eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+            print(e)
+            logger.exception(e)
+            raise e
+    
+    except Exception as e:
+        print('Exception eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee')
+        print(e)
+        logger.exception(e)
+        raise e
+
+
+def run_router_chain(query):
+    try:
+        logger.info(f"run_router_chain : Question: {query}")
+        # Get the answer from the chain
+        start = time.time()
+        chain_type = router_chain.invoke(query)['text']
+        end = time.time()
+
+        # log the result
+        logger.info(f"Answer (took {round(end - start, 2)} s.) chain_type: {chain_type}")
+
+        return chain_type
+    
+    except Exception as e:
+        logger.exception(e)
+        raise e
+
+
+def run_qa_chain(query):
+    try:
+        logger.info(f"run_qa_chain : Question: {query}")
+        # Get the answer from the chain
+        start = time.time()
+        # res = qa_chain(query)
+        res = qa_chain.invoke({"question": query, "chat_history":""})
+        # res = response
+        # answer, docs = res['result'],res['source_documents']
+        end = time.time()
+
+        # log the result
+        logger.info(f"Answer (took {round(end - start, 2)} s.) \n: {res}")
+
+        return qa_chain_output_parser(res)
+    
+    except Exception as e:
+        logger.exception(e)
+        raise e
+
+
+def run_general_qa_chain(query):
+    try:
+        logger.info(f"run_general_qa_chain : Question: {query}")
+
+        # Get the answer from the chain
+        start = time.time()
+        res = general_qa_chain.invoke(query)
+        end = time.time()
+
+        # log the result
+       
+        logger.info(f"Answer (took {round(end - start, 2)} s.) \n: {res}")
+
+        return general_qa_chain_output_parser(res)
+
+    except Exception as e:
+        logger.exception(e)
+        raise e
+
+
+def run_out_of_domain_chain(query):
+    return out_of_domain_chain_parser(query)

retriever.py

@@ -0,0 +1,137 @@
+
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 19/03/2023
+ *  LastModifiedDate : 19/03/2024
+ *************************************************************************/
+ """
+
+"""
+Ensemble retriever that ensemble the results of 
+multiple retrievers by using weighted  Reciprocal Rank Fusion
+"""
+
+import logging
+logger = logging.getLogger(__name__)
+
+from faissDb import load_FAISS_store
+
+from langchain_community.retrievers import BM25Retriever
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+
+from langchain.schema import Document
+from typing import Iterable
+import json
+
+def save_docs_to_jsonl(array:Iterable[Document], file_path:str)->None:
+    with open(file_path, 'w') as jsonl_file:
+        for doc in array:
+            jsonl_file.write(doc.json() + '\n')
+
+def load_docs_from_jsonl(file_path)->Iterable[Document]:
+    array = []
+    with open(file_path, 'r') as jsonl_file:
+        for line in jsonl_file:
+            data = json.loads(line)
+            obj = Document(**data)
+            array.append(obj)
+    return array
+
+def split_documents():
+    chunk_size=2000
+    chunk_overlap=100
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=chunk_overlap)
+
+    years = [2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024]
+    docs_list=[]
+    splits_list=[]
+
+
+    for year in years:
+        data_path= f"data/CBSL/{year}"
+        logger.info(f"Loading year : {data_path}")
+
+        documents = DirectoryLoader(data_path,  loader_cls=PyPDFLoader).load()
+
+        for doc in documents:
+            doc.metadata['year']=year
+            logger.info(f"{doc.metadata['year']} : {doc.metadata['source']}" )
+            docs_list.append(doc)
+
+        texts = text_splitter.split_documents(documents)
+        for text in texts:
+            splits_list.append(text)
+
+    splitted_texts_file='data/splitted_texts.jsonl'
+    save_docs_to_jsonl(splits_list,splitted_texts_file)
+
+from ensemble_retriever import EnsembleRetriever
+from multi_query_retriever import MultiQueryRetriever
+
+def load_faiss_retriever():
+    try:
+        vectorstore=load_FAISS_store()
+        retriever = vectorstore.as_retriever(
+            # search_type="mmr",
+            search_kwargs={'k': 5, 'fetch_k': 10}
+            )
+        logger.info("FAISS Retriever loaded:")
+        return retriever
+    
+    except Exception as e:
+        logger.exception(e)
+        raise e
+    
+def load_ensemble_retriever():
+    try:
+        # splitted_texts_file=os.path.dirname(os.path.abspath(__file__).join('/data/splitted_texts.jsonl'))
+        splitted_texts_file='./data/splitted_texts.jsonl'
+        sementic_k = 4
+        bm25_k = 2
+        splits_list = load_docs_from_jsonl(splitted_texts_file)
+
+        bm25_retriever  = BM25Retriever.from_documents(splits_list)
+        bm25_retriever.k = bm25_k
+
+        faiss_vectorstore = load_FAISS_store()
+        faiss_retriever  = faiss_vectorstore.as_retriever(search_kwargs={'k': sementic_k,})
+        
+        ensemble_retriever = EnsembleRetriever(retrievers=[bm25_retriever, faiss_retriever], weights=[0.5, 0.5])
+        ensemble_retriever.top_k=4
+        
+        logger.info("EnsembleRetriever loaded:")
+        return ensemble_retriever
+    
+    except Exception as e:
+        logger.exception(e)
+        raise e
+
+from llm import get_model
+
+def load_multi_query_retriever(multi_query_model_type):
+    #multi query
+    try:
+        llm = get_model(multi_query_model_type)
+        ensembleRetriever = load_ensemble_retriever()
+        retriever  = MultiQueryRetriever.from_llm(
+            retriever=ensembleRetriever,
+            llm=llm
+        )
+        logger.info("MultiQueryRetriever loaded:")
+        return retriever
+
+    except Exception as e:
+        logger.exception(e)
+        raise e

schema.py

@@ -0,0 +1,63 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2025) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 15/10/2024
+ *************************************************************************/
+"""
+
+from typing import Optional, List, Any, Dict
+from pydantic import BaseModel
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+# model for front end session
+# Output model (UserModel response)
+class UserModel(BaseModel):
+    userId: int
+    firstName: str
+    lastName: str
+    userName: str
+    token: str
+
+
+class UserQuery(BaseModel):
+    content: str
+    userId: int
+    aiModel: int = "default"
+
+
+class Document(BaseModel):
+    name: Optional[str]
+    page_content: str
+    metadata: Dict[str, Any]
+
+
+class ResponseModel(BaseModel):
+    question: str
+    answer: str
+    source_documents: List[Document] = None
+
+
+# class Feedback(BaseModel):
+#     """
+#     Schema for collecting feedback from the user.
+#     It includes the question, bot response, and user feedback.
+#     """
+
+#     question: str
+#     botResponse: str
+#     userFeedback: str
+#     feedback: str

server.py

@@ -0,0 +1,173 @@
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2025) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 14/11/2023
+ *  LastModifiedDate : 15/10/2024
+ *************************************************************************/
+"""
+
+import os
+import time
+import sys
+import logging
+import datetime
+import uvicorn
+from dotenv import load_dotenv
+
+from fastapi import FastAPI, APIRouter, HTTPException, status
+from fastapi import HTTPException, status
+from fastapi.middleware.cors import CORSMiddleware
+
+from schema import UserQuery, ResponseModel, Document, LoginRequest, UserModel
+from controller import get_QA_Answers, get_avaliable_models
+
+
+def filer():
+    return "logs/log"
+    # today = datetime.datetime.today()
+    # log_filename = f"logs/{today.year}-{today.month:02d}-{today.day:02d}.log"
+    # return log_filename
+
+
+file_handler = logging.FileHandler(filer())
+# file_handler = logging.handlers.TimedRotatingFileHandler(filer(),when="D")
+file_handler.setLevel(logging.INFO)
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s %(levelname)s (%(name)s) : %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+    handlers=[file_handler],
+    force=True,
+)
+
+logger = logging.getLogger(__name__)
+
+load_dotenv()
+host = os.environ.get("APP_HOST")
+port = int(os.environ.get("APP_PORT"))
+
+
+class ChatAPI:
+
+    def __init__(self):
+        self.router = APIRouter()
+        self.router.add_api_route("/api/v1/health", self.hello, methods=["GET"])
+        self.router.add_api_route("/api/v1/models", self.avaliable_models, methods=["GET"])
+        self.router.add_api_route(
+            "/api/v1/login", self.login, methods=["POST"], response_model=UserModel
+        )
+        self.router.add_api_route("/api/v1/chat", self.chat, methods=["POST"])
+
+    async def hello(self):
+        return "Hello there!"
+
+    async def avaliable_models(self):
+        logger.info("getting avaliable models")
+        models = get_avaliable_models()
+
+        if not models:
+            logger.exception("models not found")
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="models not found"
+            )
+
+        return models
+
+    async def login(self, login_request: LoginRequest):
+        logger.info(f"username password: {login_request} ")
+        # Dummy user data for demonstration (normally, you'd use a database)
+        dummy_users_db = {
+            "john_doe": {
+                "userId": 1,
+                "firstName": "John",
+                "lastName": "Doe",
+                "userName": "john_doe",
+                "password": "password",  # Normally, passwords would be hashed and stored securely
+                "token": "dummy_token_123",  # In a real scenario, this would be a JWT or another kind of token
+            }
+        }
+        # Fetch user by username
+        # user = dummy_users_db.get(login_request.username)
+        user = dummy_users_db.get("john_doe")
+        # Validate user credentials
+        if not user or user["password"] != login_request.password:
+            raise HTTPException(status_code=401, detail="Invalid username or password")
+
+        # Return the user model without the password
+        return UserModel(
+            userId=user["userId"],
+            firstName=user["firstName"],
+            lastName=user["lastName"],
+            userName=user["userName"],
+            token=user["token"],
+        )
+
+    async def chat(
+        self, userQuery: UserQuery
+    ):  #:UserQuery):# -> ResponseModel: #chat: QueryModel): # -> ResponseModel:
+        """Makes query to doc store via Langchain pipeline.
+
+        :param chat.: question, model, dataset location, history of the chat.
+        :type chat: QueryModel
+        """
+        logger.info(f"userQuery: {userQuery} ")
+
+        try:
+            start = time.time()
+            res = get_QA_Answers(userQuery)
+            logger.info(
+                f"--------------------------  answer: {res} -------------------------- "
+            )
+            # return res
+            end = time.time()
+            logger.info(
+                f"-------------------------- Server process (took {round(end - start, 2)} s.) \n: {res}"
+            )
+            print(
+                f" \n -------------------------- Server process (took {round(end - start, 2)} s.) -------------------------  \n"
+            )
+            return res
+
+        except HTTPException as e:
+            logger.exception(e)
+            raise e
+
+        except Exception as e:
+            logger.exception(e)
+            raise HTTPException(status_code=400, detail=f"Error : {e}")
+
+
+# initialize API
+app = FastAPI(title="Boardpac chatbot API")
+api = ChatAPI()
+app.include_router(api.router)
+
+# origins = ['http://localhost:8000','http://192.168.10.100:8000']
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+if __name__ == "__main__":
+
+    host = "0.0.0.0"
+    port = 8000
+
+    # config = uvicorn.Config("server:app",host=host, port=port, log_config= logging.basicConfig())
+    config = uvicorn.Config("server:app", host=host, port=port)
+    server = uvicorn.Server(config)
+    server.run()
+    # uvicorn.run(app)

utils/utils.py

@@ -0,0 +1,40 @@
+"""
+Python Backend API to chat with private data  
+15/11/2023
+Theekshana Samaradiwakara
+"""
+"""
+ /*************************************************************************
+ * 
+ * CONFIDENTIAL
+ * __________________
+ * 
+ *  Copyright (2023-2024) AI Labs, IronOne Technologies, LLC
+ *  All Rights Reserved
+ *
+ *  Author  : Theekshana Samaradiwakara
+ *  Description :Python Backend API to chat with private data  
+ *  CreatedDate : 15/11/2023
+ *  LastModifiedDate : 10/12/2020
+ *************************************************************************/
+ """
+
+# from passlib.context import CryptContext
+# pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+# def hash(password: str):
+#     return pwd_context.hash(password)
+
+
+# def verify(plain_password, hashed_password):
+#     return pwd_context.verify(plain_password, hashed_password)
+
+
+
+import re
+def is_valid_open_ai_api_key(secretKey):
+    if re.search("^sk-[a-zA-Z0-9]{32,}$", secretKey ): 
+        return True
+    else: return False
+