Upload folder using huggingface_hub

pipelines/.dockerignore

@@ -0,0 +1 @@
+__pycache__

pipelines/.env.example

@@ -0,0 +1,23 @@
+llm_api_1 = ""
+llm_api_2 = ""
+llm_api_3 = ""
+llm_api_4 = ""
+llm_api_5 = ""
+llm_api_6=""
+llm_api_7=""
+llm_api_8=""
+llm_api_9=""
+llm_api_10=""
+COHERE_API_KEY=mvJsIewR1qw6LKmauMtoHubyINaAAjdZtZWadkc4
+FASTAPI_URL = https://fast-api.snova.ai/v1/chat/completions
+FASTAPI_API_KEY = ""
+
+
+
+# mistral api key 
+MISTRAL_API_KEY1= ""
+
+
+
+#openai key 
+OPENAI_KEY = ""

pipelines/.gitignore

@@ -0,0 +1,12 @@
+__pycache__
+.env
+
+/litellm
+
+
+pipelines/*
+!pipelines/.gitignore
+.DS_Store
+
+.venv
+venv/

pipelines/BM25/__init__.py

@@ -0,0 +1 @@
+from BM25.bm25sretriever import BM25SRetriever

pipelines/BM25/bm25sretriever.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Callable, Dict, Iterable, List, Optional
+
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.pydantic_v1 import Field
+from langchain_core.retrievers import BaseRetriever
+import bm25s
+import re
+import string
+from tqdm import tqdm
+from pyvi.ViTokenizer import tokenize
+
+def clean_text(text: str) -> str:
+    text = re.sub('<.*?>', '', text).strip()
+    text = text.encode('utf-8', 'ignore').decode('utf-8')
+    
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def normalize_text(text: str) -> str:
+    list_punctuation = string.punctuation.replace('_', '')
+    
+    for punct in list_punctuation:
+        text = text.replace(punct, ' ')
+    
+    text = text.lower().strip()
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def process_text(text: str) -> str:
+    text = clean_text(text)
+    text = tokenize(text)
+    text = normalize_text(text)
+    return text
+
+def default_preprocessing_func(text: str) -> List[str]:
+    if type(text) == tuple :
+        fin_text = [process_text(doc) for doc in tqdm(text)]
+    elif type(text) == str :
+        fin_text = process_text(text)
+    token_corpus = bm25s.tokenize(texts=fin_text, stopwords = "vi", return_ids= False , show_progress=False)
+    return token_corpus
+
+
+class BM25SRetriever(BaseRetriever):
+    """A toy retriever that contains the top k documents that contain the user query.
+
+    This retriever only implements the sync method _get_relevant_documents.
+
+    If the retriever were to involve file access or network access, it could benefit
+    from a native async implementation of `_aget_relevant_documents`.
+
+    As usual, with Runnables, there's a default async implementation that's provided
+    that delegates to the sync implementation running on another thread.
+    """
+    vectorizer: Any
+    """ BM25S vectorizer."""
+    docs: List[Document] = Field(repr=False)
+    """List of documents to retrieve from."""
+    k: int = 4
+    """Number of top results to return"""
+    preprocess_func: Callable[[str], List[str]] = default_preprocessing_func
+    """ Preprocessing function to use on the text before BM25 vectorization."""
+    save_directory : Optional[str] = None
+    """ Directory for saving BM25S index."""
+    activate_numba: bool = False
+    """Accelerate backend"""
+    class Config:
+        arbitrary_types_allowed = True
+    @classmethod
+    def from_texts(
+        cls,
+        texts: Iterable[str],
+        metadatas: Optional[Iterable[dict]] = None,
+        bm25_params: Optional[Dict[str, Any]] = None,
+        save_directory : Optional[str] = save_directory,
+        preprocess_func: Callable[[str], List[str]] = default_preprocessing_func,
+        **kwargs: Any,
+    ) -> BM25SRetriever:
+        """
+        Create a BM25Retriever from a list of texts.
+        Args:
+            texts: A list of texts to vectorize.
+            metadatas: A list of metadata dicts to associate with each text.
+            bm25s_params: Parameters to pass to the BM25s vectorizer.
+            preprocess_func: A function to preprocess each text before vectorization.
+            **kwargs: Any other arguments to pass to the retriever.
+
+        Returns:
+            A BM25SRetriever instance.
+        """
+        try:
+            from bm25s import BM25
+        except ImportError:
+            raise ImportError(
+                "Could not import bm25s, please install with `pip install "
+                "bm25s`."
+            )
+        bm25_params = bm25_params or {}
+        if save_directory and Path(save_directory).exists():
+            try:
+                vectorizer = BM25.load(save_directory)
+            except Exception as e:
+                print(f"Failed to load BM25 index from {save_directory}: {e}")
+                print("Proceeding with indexing from scratch.")
+                texts_processed = preprocess_func(texts)
+                vectorizer = BM25(**bm25_params)
+                vectorizer.index(texts_processed)
+                if save_directory:
+                    vectorizer.save(save_directory)
+
+        else:
+            texts_processed = preprocess_func(texts)
+            vectorizer = BM25(**bm25_params)
+            vectorizer.index(texts_processed)
+            if save_directory:
+                vectorizer.save(save_directory)
+
+        metadatas = metadatas or ({} for _ in texts)
+        docs = [Document(page_content=t, metadata=m) for t, m in zip(texts, metadatas)]
+        return cls(
+            vectorizer=vectorizer, docs=docs, preprocess_func=preprocess_func, save_directory=save_directory, **kwargs
+        )
+
+    @classmethod
+    def from_documents(
+        cls,
+        documents: Iterable[Document],
+        *,
+        bm25_params: Optional[Dict[str, Any]] = None,
+        preprocess_func: Callable[[str], List[str]] = default_preprocessing_func,
+
+        **kwargs: Any,
+    ) -> BM25SRetriever:
+        """
+        Create a BM25Retriever from a list of Documents.
+        Args:
+            documents: A list of Documents to vectorize.
+            bm25_params: Parameters to pass to the BM25 vectorizer.
+            preprocess_func: A function to preprocess each text before vectorization.
+            **kwargs: Any other arguments to pass to the retriever.
+
+        Returns:
+            A BM25Retriever instance.
+        """
+        texts, metadatas = zip(*((d.page_content, d.metadata) for d in documents))
+        return cls.from_texts(
+            texts=texts,
+            bm25_params=bm25_params,
+            metadatas=metadatas,
+            preprocess_func=preprocess_func,
+            **kwargs,
+        )
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun
+    ) -> List[Document]:
+        processed_query = self.preprocess_func(query)
+        if self.activate_numba : 
+          self.vectorizer.activate_numba_scorer()
+          return_docs = self.vectorizer.retrieve(processed_query, k=self.k, backend_selection="numba")
+          return [self.docs[i] for i in return_docs.documents[0]]
+        else :  
+          return_docs, scores = self.vectorizer.retrieve(processed_query, self.docs, k = self.k)
+          return [return_docs[0, i] for i in range(return_docs.shape[1])]

pipelines/BM25/preprocess.py

@@ -0,0 +1,21 @@
+import re
+import string
+from pyvi.ViTokenizer import tokenize
+import bm25s
+
+def clean_text(text):
+    text = re.sub('<.*?>', '', text).strip()
+    text = re.sub(r'(\s)+', r'\1', text)
+    return text
+
+def normalize_text(text):
+    listpunctuation = string.punctuation.replace('_', '')
+    for i in listpunctuation:
+        text = text.replace(i, ' ')
+    return text.lower().strip()
+
+def process_text(text):
+    text = clean_text(text)
+    text = tokenize(text)
+    text = normalize_text(text)
+    return text

pipelines/CONTRIBUTING.md

@@ -0,0 +1,50 @@
+## Contributing to Pipelines
+
+🚀 **Welcome, Contributors!** 🚀
+
+We are thrilled to have you join the Pipelines community! Your contributions are essential to making Pipelines a powerful and versatile framework for extending OpenAI-compatible applications' capabilities. This document provides guidelines to ensure your contributions are smooth and effective.
+
+### 📌 Key Points
+
+- **Scope of Pipelines:** Remember that Pipelines is a framework designed to enhance OpenAI interactions, specifically through a plugin-like approach. Focus your contributions on making Pipelines more robust, flexible, and user-friendly within this context.
+- **Open WebUI Integration:** Pipelines is primarily designed to work with Open WebUI. While contributions that expand compatibility with other platforms are welcome, prioritize functionalities that seamlessly integrate with Open WebUI's ecosystem.
+
+### 🚨 Reporting Issues
+
+Encountered a bug or have an idea for improvement? We encourage you to report it! Here's how:
+
+1. **Check Existing Issues:**  Browse the [Issues tab](https://github.com/open-webui/pipelines/issues) to see if the issue or suggestion has already been reported.
+2. **Open a New Issue:** If it's a new issue, feel free to open one. Follow the issue template for clear and concise reporting. Provide detailed descriptions, steps to reproduce, expected outcomes, and actual results. This helps us understand and resolve the issue efficiently.
+
+### 🧭 Scope of Support
+
+- **Python Fundamentals:** Pipelines leverages Python. Basic Python knowledge is essential for contributing effectively.
+
+## 💡 Contributing
+
+Ready to make a difference? Here's how you can contribute to Pipelines:
+
+### 🛠 Pull Requests
+
+We encourage pull requests to improve Pipelines! Here's the process:
+
+1. **Discuss Your Idea:** If your contribution involves significant changes, discuss it in the [Issues tab](https://github.com/open-webui/pipelines/issues) first. This ensures your idea aligns with the project's vision.
+2. **Coding Standards:** Follow the project's coding standards and write clear, descriptive commit messages.
+3. **Update Documentation:**  If your contribution impacts documentation, update it accordingly.
+4. **Submit Your Pull Request:** Submit your pull request and provide a clear summary of your changes.
+
+### 📚 Documentation
+
+Help make Pipelines more accessible by:
+
+- **Writing Tutorials:** Create guides for setting up, using, and customizing Pipelines.
+- **Improving Documentation:**  Enhance existing documentation for clarity, completeness, and accuracy.
+- **Adding Examples:**  Contribute pipelines examples that showcase different functionalities and use cases.
+
+### 🤔 Questions & Feedback
+
+Got questions or feedback? Join our [Discord community](https://discord.gg/5rJgQTnV4s) or open an issue. We're here to help!
+
+## 🙏 Thank You!
+
+Your contributions are invaluable to Pipelines' success! We are excited to see what you bring to the project. Together, we can create a powerful and versatile framework for extending OpenAI capabilities. 🌟

pipelines/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Timothy Jaeryang Baek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+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.

pipelines/README.md

@@ -0,0 +1,114 @@
+<p align="center">
+  <a href="#"><img src="./header.png" alt="Pipelines Logo"></a>
+</p>
+
+# Pipelines: UI-Agnostic OpenAI API Plugin Framework
+
+Welcome to **Pipelines**, an [Open WebUI](https://github.com/open-webui) initiative. Pipelines bring modular, customizable workflows to any UI client supporting OpenAI API specs – and much more! Easily extend functionalities, integrate unique logic, and create dynamic workflows with just a few lines of code.
+
+## 🚀 Why Choose Pipelines?
+
+- **Limitless Possibilities:** Easily add custom logic and integrate Python libraries, from AI agents to home automation APIs.
+- **Seamless Integration:** Compatible with any UI/client supporting OpenAI API specs. (Only pipe-type pipelines are supported; filter types require clients with Pipelines support.)
+- **Custom Hooks:** Build and integrate custom pipelines.
+
+### Examples of What You Can Achieve:
+
+- [**Function Calling Pipeline**](/examples/filters/function_calling_filter_pipeline.py): Easily handle function calls and enhance your applications with custom logic.
+- [**Custom RAG Pipeline**](/examples/pipelines/rag/llamaindex_pipeline.py): Implement sophisticated Retrieval-Augmented Generation pipelines tailored to your needs.
+- [**Message Monitoring Using Langfuse**](/examples/filters/langfuse_filter_pipeline.py): Monitor and analyze message interactions in real-time using Langfuse.
+- [**Rate Limit Filter**](/examples/filters/rate_limit_filter_pipeline.py): Control the flow of requests to prevent exceeding rate limits.
+- [**Real-Time Translation Filter with LibreTranslate**](/examples/filters/libretranslate_filter_pipeline.py): Seamlessly integrate real-time translations into your LLM interactions.
+- [**Toxic Message Filter**](/examples/filters/detoxify_filter_pipeline.py): Implement filters to detect and handle toxic messages effectively.
+- **And Much More!**: The sky is the limit for what you can accomplish with Pipelines and Python. [Check out our scaffolds](/examples/scaffolds) to get a head start on your projects and see how you can streamline your development process!
+
+## 🔧 How It Works
+
+<p align="center">
+  <a href="./docs/images/workflow.png"><img src="./docs/images/workflow.png" alt="Pipelines Workflow"></a>
+</p>
+
+Integrating Pipelines with any OpenAI API-compatible UI client is simple. Launch your Pipelines instance and set the OpenAI URL on your client to the Pipelines URL. That's it! You're ready to leverage any Python library for your needs.
+
+## ⚡ Quick Start with Docker
+
+> [!WARNING]
+> Pipelines are a plugin system with arbitrary code execution — **don't fetch random pipelines from sources you don't trust**.
+
+For a streamlined setup using Docker:
+
+1. **Run the Pipelines container:**
+
+   ```sh
+   docker run -d -p 9099:9099 --add-host=host.docker.internal:host-gateway -v pipelines:/app/pipelines --name pipelines --restart always ghcr.io/open-webui/pipelines:main
+   ```
+
+2. **Connect to Open WebUI:**
+
+   - Navigate to the **Settings > Connections > OpenAI API** section in Open WebUI.
+   - Set the API URL to `http://localhost:9099` and the API key to `0p3n-w3bu!`. Your pipelines should now be active.
+
+> [!NOTE]
+> If your Open WebUI is running in a Docker container, replace `localhost` with `host.docker.internal` in the API URL.
+
+3. **Manage Configurations:**
+
+   - In the admin panel, go to **Admin Settings > Pipelines tab**.
+   - Select your desired pipeline and modify the valve values directly from the WebUI.
+
+> [!TIP]
+> If you are unable to connect, it is most likely a Docker networking issue. We encourage you to troubleshoot on your own and share your methods and solutions in the discussions forum.
+
+If you need to install a custom pipeline with additional dependencies:
+
+- **Run the following command:**
+
+  ```sh
+  docker run -d -p 9099:9099 --add-host=host.docker.internal:host-gateway -e PIPELINES_URLS="https://github.com/open-webui/pipelines/blob/main/examples/filters/detoxify_filter_pipeline.py" -v pipelines:/app/pipelines --name pipelines --restart always ghcr.io/open-webui/pipelines:main
+  ```
+
+Alternatively, you can directly install pipelines from the admin settings by copying and pasting the pipeline URL, provided it doesn't have additional dependencies.
+
+That's it! You're now ready to build customizable AI integrations effortlessly with Pipelines. Enjoy!
+
+## 📦 Installation and Setup
+
+Get started with Pipelines in a few easy steps:
+
+1. **Ensure Python 3.11 is installed.**
+2. **Clone the Pipelines repository:**
+
+   ```sh
+   git clone https://github.com/open-webui/pipelines.git
+   cd pipelines
+   ```
+
+3. **Install the required dependencies:**
+
+   ```sh
+   pip install -r requirements.txt
+   ```
+
+4. **Start the Pipelines server:**
+
+   ```sh
+   sh ./start.sh
+   ```
+
+Once the server is running, set the OpenAI URL on your client to the Pipelines URL. This unlocks the full capabilities of Pipelines, integrating any Python library and creating custom workflows tailored to your needs.
+
+## 📂 Directory Structure and Examples
+
+The `/pipelines` directory is the core of your setup. Add new modules, customize existing ones, and manage your workflows here. All the pipelines in the `/pipelines` directory will be **automatically loaded** when the server launches.
+
+You can change this directory from `/pipelines` to another location using the `PIPELINES_DIR` env variable.
+
+### Integration Examples
+
+Find various integration examples in the `/examples` directory. These examples show how to integrate different functionalities, providing a foundation for building your own custom pipelines.
+
+## 🎉 Work in Progress
+
+We’re continuously evolving! We'd love to hear your feedback and understand which hooks and features would best suit your use case. Feel free to reach out and become a part of our Open WebUI community!
+
+Our vision is to push **Pipelines** to become the ultimate plugin framework for our AI interface, **Open WebUI**. Imagine **Open WebUI** as the WordPress of AI interfaces, with **Pipelines** being its diverse range of plugins. Join us on this exciting journey! 🌍

pipelines/Router/__init__.py

@@ -0,0 +1 @@
+from Router.router import Evaluator

pipelines/Router/router.py

@@ -0,0 +1,45 @@
+from pydantic import BaseModel, field_validator 
+from typing import Optional
+import os
+from llmdantic import LLMdantic, LLMdanticConfig  
+from sambanova.langchain_wrappers import SambaNovaFastAPI
+from dotenv import load_dotenv
+from llmdantic import LLMdanticResult
+
+
+current_dir = os.getcwd()
+utils_dir = os.path.abspath(os.path.join(current_dir, '..'))
+load_dotenv(os.path.join(utils_dir, '.env'), override=True)
+# load_dotenv('.env', override=True)
+
+
+class Catergories_Classify_Input(BaseModel):
+    text: str
+
+class Catergories_Classify_Output(BaseModel):
+    result: str
+
+    @field_validator("result")
+    def catergory_result_must_not_be_empty(cls, v) -> bool:
+        """Category result must not be empty"""
+        if not v.strip():
+            raise ValueError("Category result must not be empty")
+        return v
+
+
+class Evaluator:
+    def __init__(self, llm : Optional[str], prompt: str):
+        self.llm = SambaNovaFastAPI(model=llm, fastapi_url = "https://fast-api.snova.ai/v1/chat/completions" , fastapi_api_key = "dHVhbmFuaC5uay4xOF9fZ21haWwuY29tOlRWbG9yQkxhNUY=")
+        self.prompt = prompt
+        self.config = LLMdanticConfig(
+            objective=self.prompt,
+            inp_schema=Catergories_Classify_Input,
+            out_schema=Catergories_Classify_Output, 
+            retries=5,
+        )
+        self.llmdantic = LLMdantic(llm=self.llm, config=self.config)
+    
+    def classify_text(self, text: str) -> Optional[Catergories_Classify_Output]:
+        data = Catergories_Classify_Input(text=text)
+        result: LLMdanticResult = self.llmdantic.invoke(data)
+        return result.output

pipelines/SafetyChecker/__init__.py

@@ -0,0 +1 @@
+from SafetyChecker.safety_checker import SafetyChecker

pipelines/SafetyChecker/safety_checker.py

@@ -0,0 +1,98 @@
+import logging
+import os
+from dotenv import load_dotenv
+from typing import Optional
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_groq import ChatGroq
+import requests
+load_dotenv()
+
+policy_mapping = {
+    "S1": "Tội phạm bạo lực",
+    "S2": "Tội phạm không bạo lực",
+    "S3": "Tội phạm liên quan đến tình dục",
+    "S4": "Khai thác tình dục trẻ em",
+    "S5": "Phỉ báng",
+    "S6": "Tư vấn chuyên biệt",
+    "S7": "Riêng tư",
+    "S8": "Sở hữu trí tuệ",
+    "S9": "Vũ khí không phân biệt",
+    "S10": "Thù ghét",
+    "S11": "Tự sát & Tự gây hại",
+    "S12": "Nội dung tình dục",
+    "S13": "Bầu cử",
+    "S14": "Ngôn ngữ xúc phạm và thô tục"
+}
+
+class SafetyChecker(BaseModel):
+    model_name: str = Field(default="llama-guard-3-8b")
+    temperature: float = Field(default=0.0)
+    api_key: Optional[str] = Field(default=None)
+    prompt_safe: Optional[ChatPromptTemplate] = None
+    system_prompt: str = Field(default="""Task type
+Check if there is unsafe content in the messages in conversations according to our safety policy with the below categories.
+
+Policy
+<BEGIN UNSAFE CONTENT CATEGORIES>
+S1: Violent Crimes.
+S2: Non-Violent Crimes
+S3: Sex-Related Crimes
+S4: Child Sexual Exploitation
+S5: Defamation
+S6: Specialized Advice
+S7: Privacy
+S8: Intellectual Property
+S9: Indiscriminate Weapon
+S10: Hate
+S11: Suicide & Self-Harm
+S12: Sexual Content
+S13: Elections
+S14: Offensive and Vulgar Language
+<END UNSAFE CONTENT CATEGORIES>
+Output format
+Provide your safety assessment for user message in the below :
+First line must read 'safe' or 'unsafe'.
+
+If unsafe, a second line must include a comma-separated list of violated categories.
+""")
+    
+ 
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __init__(self, api_key: Optional[str] = None, **data):
+        super().__init__(**data)
+        load_dotenv()
+        self.api_key = api_key
+        # Initialize the ChatPromptTemplate as an instance attribute
+        self.prompt_safe = ChatPromptTemplate.from_messages(
+            [
+                ("system", self.system_prompt),
+                ("human", "{question}"),
+            ]
+        )
+
+    def check_safety(self, question: str) -> str:
+        llm = ChatGroq(model_name=self.model_name, temperature=self.temperature, api_key=self.api_key)
+        question_save = self.prompt_safe | llm
+        out = question_save.invoke({"question": question})
+        result_lines = out.content.strip().split('\n')
+        
+        if result_lines[0] == 'unsafe':
+            # Retrieve the violated categories
+            violated_categories = result_lines[1]
+            categories = violated_categories.split(',')
+            
+            # Trim whitespace and look up descriptions
+            category_descriptions = [policy_mapping.get(cat.strip(), cat.strip()) for cat in categories]
+            
+            # Join descriptions into a single string
+            descriptions_str = ', '.join(category_descriptions)
+            
+            return f"Câu hỏi không được cho phép vì vi phạm chính sách an toàn cộng đồng : {descriptions_str}"
+        
+        return "safe"
+
+

pipelines/bk/semantic_cache/Cache.py

@@ -0,0 +1,207 @@
+import json
+import time
+import faiss
+
+##############################Sentence_Bert#########################################
+
+import numpy as np
+from sentence_transformers import SentenceTransformer  # pylint: disable=C0413
+
+from abc import ABCMeta, abstractmethod
+
+
+class BaseEmbedding(metaclass=ABCMeta):
+    """
+    Base Embedding interface.
+    """
+
+    @abstractmethod
+    def to_embeddings(self, data, **kwargs):
+        pass
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:
+        return 0
+
+
+
+class SBERT(BaseEmbedding):
+    """Generate sentence embedding for given text using pretrained models of Sentence Transformers.
+
+    :param model: model name, defaults to 'all-MiniLM-L6-v2'.
+    :type model: str
+
+    Example:
+        .. code-block:: python
+
+            from gptcache.embedding import SBERT
+
+            test_sentence = 'Hello, world.'
+            encoder = SBERT('all-MiniLM-L6-v2')
+            embed = encoder.to_embeddings(test_sentence)
+    """
+
+    def __init__(self, model: str = "all-MiniLM-L6-v2"):
+        self.model = SentenceTransformer(model)
+        self.model.eval()
+        self.__dimension = None
+
+    def to_embeddings(self, data, **_):
+        """Generate embedding given text input
+
+        :param data: text in string.
+        :type data: str
+
+        :return: a text embedding in shape of (dim,).
+        """
+        if not isinstance(data, list):
+            data = [data]
+        emb = self.model.encode(data)
+        _, dim = emb.shape
+        if not self.__dimension:
+            self.__dimension = dim
+        return np.array(emb).astype("float32")
+
+    @property
+    def dimension(self):
+        """Embedding dimension.
+
+        :return: embedding dimension
+        """
+        if not self.__dimension:
+           embd = self.model.encode(["foo"])
+           _, self.__dimension = embd.shape
+        return self.__dimension
+    
+
+
+#################################### Adapter ########################################
+def init_cache(embedding_model: str = "all-MiniLM-L6-v2"):
+    """Initializes the cache with a Faiss index and an SBERT model.
+
+    Args:
+    embedding_model (str): The name of the SBERT model to use.
+
+    Returns:
+    tuple: (index, encoder) where
+        - index is a Faiss index for storing embeddings.
+        - encoder is an SBERT model instance.
+    """
+
+    encoder = SBERT(embedding_model)
+    dimension = encoder.dimension
+    print(dimension)
+    index = faiss.IndexFlatL2(dimension)
+    if index.is_trained:
+        print('Index initialized and ready for use')
+
+    return index, encoder
+
+
+def retrieve_cache(json_file):
+  try:
+    with open(json_file, 'r') as file:
+      cache = json.load(file)
+  except FileNotFoundError:
+      cache = {'questions': [], 'answers': []}
+
+  return cache
+
+
+
+def store_cache(json_file, cache):
+  with open(json_file, 'w', encoding = 'utf-8') as file:
+    json.dump(cache, file)
+
+#####################################################################3
+class Cache:
+    def __init__(self, embedding = "all-MiniLM-L6-v2" ,  json_file="cache_file.json", thresold=0.5, max_response=100, eviction_policy='FIFO'):
+        """Initializes the semantic cache.
+
+        Args:
+        json_file (str): The name of the JSON file where the cache is stored.
+        thresold (float): The threshold for the Euclidean distance to determine if a question is similar.
+        max_response (int): The maximum number of responses the cache can store.
+        eviction_policy (str): The policy for evicting items from the cache.
+                                This can be any policy, but 'FIFO' (First In First Out) has been implemented for now.
+                                If None, no eviction policy will be applied.
+        """
+
+        # Initialize Faiss index with Euclidean distance
+        self.index, self.encoder = init_cache(embedding)
+
+        # Set Euclidean distance threshold
+        # a distance of 0 means identicals sentences
+        # We only return from cache sentences under this thresold
+        self.euclidean_threshold = thresold
+        self.is_missed = True
+        self.json_file = json_file
+        self.cache = retrieve_cache(self.json_file)
+        self.max_response = max_response
+        self.eviction_policy = eviction_policy
+
+    def evict(self):
+
+        """Evicts an item from the cache based on the eviction policy."""
+        if self.eviction_policy and len(self.cache["questions"]) > self.max_response:
+            for _ in range((len(self.cache["questions"]) - self.max_response)):
+                if self.eviction_policy == 'FIFO':
+                    self.cache["questions"].pop(0)
+                    self.cache["answers"].pop(0)
+    def cached_hit(self, question: str) -> str:
+            """Handles the cache hit logic by retrieving the answer from the cache.
+
+            Args:
+            question (str): The input question.
+            embedding: The embedding of the question.
+
+            Returns:
+            str: The cached answer.
+            """
+            # Search for the nearest neighbor in the index
+            embedding = self.encoder.to_embeddings([question])
+            self.index.nprobe = 8
+            D, I = self.index.search(embedding, 1)
+            print(D)
+            if D[0] >= 0:
+                if I[0][0] >= 0 and D[0][0] / 100 <= self.euclidean_threshold:
+                    row_id = int(I[0][0])
+                    print('Answer recovered from Cache.')
+                    print(f'Distance: {D[0][0]:.3f} (Threshold: {self.euclidean_threshold})')
+                    print(f'Found in cache at row: {row_id} with score: {D[0][0]:.3f}')
+                    self.is_missed =False
+                    return self.cache['answers'][row_id]
+            self.is_missed = True
+            return embedding , self.is_missed
+
+    
+    def cache_miss(self, question: str, embedding , answer) -> str:
+        """Handles the cache miss logic by querying the model and updating the cache.
+
+        Args:
+        question (str): The input question.
+        embedding: The embedding of the question take from cache_hit if hit nothing
+        answer (str) : The answer from LLMs
+        Returns:
+        Append to cache and return answer.
+        """
+
+        # Update the cache with the new question, embedding, and answer
+        self.cache['questions'].append(question)
+        self.cache['answers'].append(answer)
+
+        print('Answer not found in cache, appending new answer.')
+        print(f'Response: {answer}')
+
+        # Add the new embedding to the index
+        self.index.add(embedding)
+
+        # Evict items if necessary
+        self.evict()
+
+        # Save the updated cache to the JSON file
+        store_cache(self.json_file, self.cache)
+        self.is_missed = False
+        return answer
+  

pipelines/bk/semantic_cache/__init__.py

@@ -0,0 +1 @@
+from semantic_cache.Cache import Cache

pipelines/bk/semantic_cache/adapter.py

@@ -0,0 +1,40 @@
+import json
+from sbert import SBERT as sentence_bert
+import faiss
+
+def init_cache(embedding_model: str = "dangvantuan/vietnamese-embedding"):
+    """Initializes the cache with a Faiss index and an SBERT model.
+
+    Args:
+    embedding_model (str): The name of the SBERT model to use.
+
+    Returns:
+    tuple: (index, encoder) where
+        - index is a Faiss index for storing embeddings.
+        - encoder is an SBERT model instance.
+    """
+
+    encoder = sentence_bert(embedding_model)
+    dimension = encoder.dimension
+    print(dimension)
+    index = faiss.IndexFlatL2(dimension)
+    if index.is_trained:
+        print('Index initialized and ready for use')
+
+    return index, encoder
+
+
+def retrieve_cache(json_file):
+  try:
+    with open(json_file, 'r') as file:
+      cache = json.load(file)
+  except FileNotFoundError:
+      cache = {'questions': [], 'answers': []}
+
+  return cache
+
+
+
+def store_cache(json_file, cache):
+  with open(json_file, 'w', encoding = 'utf-8') as file:
+    json.dump(cache, file)

pipelines/bk/semantic_cache/sbert.py

@@ -0,0 +1,70 @@
+import numpy as np
+from sentence_transformers import SentenceTransformer  # pylint: disable=C0413
+
+from abc import ABCMeta, abstractmethod
+
+
+class BaseEmbedding(metaclass=ABCMeta):
+    """
+    Base Embedding interface.
+    """
+
+    @abstractmethod
+    def to_embeddings(self, data, **kwargs):
+        pass
+
+    @property
+    @abstractmethod
+    def dimension(self) -> int:
+        return 0
+
+
+
+class SBERT(BaseEmbedding):
+    """Generate sentence embedding for given text using pretrained models of Sentence Transformers.
+
+    :param model: model name, defaults to 'all-MiniLM-L6-v2'.
+    :type model: str
+
+    Example:
+        .. code-block:: python
+
+            from gptcache.embedding import SBERT
+
+            test_sentence = 'Hello, world.'
+            encoder = SBERT('all-MiniLM-L6-v2')
+            embed = encoder.to_embeddings(test_sentence)
+    """
+
+    def __init__(self, model: str = "all-MiniLM-L6-v2"):
+        self.model = SentenceTransformer(model)
+        self.model.eval()
+        self.__dimension = None
+
+    def to_embeddings(self, data, **_):
+        """Generate embedding given text input
+
+        :param data: text in string.
+        :type data: str
+
+        :return: a text embedding in shape of (dim,).
+        """
+        if not isinstance(data, list):
+            data = [data]
+        emb = self.model.encode(data)
+        _, dim = emb.shape
+        if not self.__dimension:
+            self.__dimension = dim
+        return np.array(emb).astype("float32")
+
+    @property
+    def dimension(self):
+        """Embedding dimension.
+
+        :return: embedding dimension
+        """
+        if not self.__dimension:
+           embd = self.model.encode(["foo"])
+           _, self.__dimension = embd.shape
+        return self.__dimension
+