semantic-router 0.1.0.dev1__tar.gz → 0.1.0.dev3__tar.gz

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Aurelio AI
+Copyright (c) 2024 Aurelio AI
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/PKG-INFO

@@ -1,16 +1,18 @@
 Metadata-Version: 2.1
 Name: semantic-router
-Version: 0.1.0.dev1
+Version: 0.1.0.dev3
 Summary: Super fast semantic router for AI decision making
 License: MIT
 Author: Aurelio AI
 Author-email: hello@aurelio.ai
-Requires-Python: >=3.9,<3.13
+Requires-Python: >=3.9,<3.14
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: bedrock
 Provides-Extra: cohere
 Provides-Extra: docs
@@ -21,27 +23,26 @@ Provides-Extra: local
 Provides-Extra: mistralai
 Provides-Extra: pinecone
 Provides-Extra: postgres
-Provides-Extra: processing
 Provides-Extra: qdrant
 Provides-Extra: vision
-Requires-Dist: aiohttp (>=3.9.5,<4.0.0)
+Requires-Dist: aiohttp (>=3.10.11,<4.0.0)
+Requires-Dist: aurelio-sdk (>=0.0.16,<0.0.17)
 Requires-Dist: boto3 (>=1.34.98,<2.0.0) ; extra == "bedrock"
 Requires-Dist: botocore (>=1.34.110,<2.0.0) ; extra == "bedrock"
 Requires-Dist: cohere (>=5.9.4,<6.00) ; extra == "cohere"
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
 Requires-Dist: colorlog (>=6.8.0,<7.0.0)
-Requires-Dist: fastembed (>=0.3.0,<0.4.0) ; extra == "fastembed"
+Requires-Dist: fastembed (>=0.3.0,<0.4.0) ; (python_version < "3.13") and (extra == "fastembed")
 Requires-Dist: google-cloud-aiplatform (>=1.45.0,<2.0.0) ; extra == "google"
-Requires-Dist: llama-cpp-python (>=0.2.28,<0.2.86) ; extra == "local"
-Requires-Dist: matplotlib (>=3.8.3,<4.0.0) ; extra == "processing"
+Requires-Dist: llama-cpp-python (>=0.2.28,<0.2.86) ; (python_version < "3.13") and (extra == "local")
 Requires-Dist: mistralai (>=0.0.12,<0.1.0) ; extra == "mistralai"
 Requires-Dist: numpy (>=1.25.2,<2.0.0)
 Requires-Dist: openai (>=1.10.0,<2.0.0)
-Requires-Dist: pillow (>=10.2.0,<11.0.0) ; extra == "vision"
+Requires-Dist: pillow (>=10.2.0,<11.0.0) ; (python_version < "3.13") and (extra == "vision")
 Requires-Dist: pinecone (>=5.0.0) ; extra == "pinecone"
 Requires-Dist: pinecone-text (>=0.7.1,<0.10.0) ; extra == "hybrid"
-Requires-Dist: psycopg2 (>=2.9.9,<3.0.0) ; extra == "postgres"
-Requires-Dist: pydantic (>=2.5.3,<3.0.0)
+Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
+Requires-Dist: pydantic (>=2.10.2,<3.0.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: qdrant-client (>=1.11.1,<2.0.0) ; extra == "qdrant"
 Requires-Dist: regex (>=2023.12.25)
@@ -49,10 +50,11 @@ Requires-Dist: requests-mock (>=1.12.1,<2.0.0)
 Requires-Dist: sphinx (>=7.0.0,<8.0.0) ; extra == "docs"
 Requires-Dist: sphinxawesome-theme (>=5.2.0,<6.0.0) ; extra == "docs"
 Requires-Dist: tiktoken (>=0.6.0,<1.0.0)
-Requires-Dist: tokenizers (>=0.19) ; extra == "local"
-Requires-Dist: torch (>=2.1.0,<2.6.0) ; extra == "local" or extra == "vision"
-Requires-Dist: torchvision (>=0.17.0,<0.18.0) ; extra == "vision"
-Requires-Dist: transformers (>=4.36.2) ; extra == "local" or extra == "vision"
+Requires-Dist: tokenizers (>=0.19) ; (python_version < "3.13") and (extra == "local")
+Requires-Dist: torch (>=2.1.0,<2.6.0) ; (python_version < "3.13") and (extra == "local" or extra == "vision")
+Requires-Dist: torchvision (>=0.17.0,<0.18.0) ; (python_version < "3.13") and (extra == "vision")
+Requires-Dist: tornado (>=6.4.2,<7.0.0)
+Requires-Dist: transformers (>=4.36.2) ; (python_version < "3.13") and (extra == "local" or extra == "vision")
 Description-Content-Type: text/markdown
 
 [![Semantic Router](https://i.ibb.co.com/g423grt/semantic-router-banner.png)](https://aurelio.ai)

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-router"
-version = "0.1.0.dev1"
+version = "0.1.0.dev3"
 description = "Super fast semantic router for AI decision making"
 authors = ["Aurelio AI <hello@aurelio.ai>"]
 readme = "README.md"
@@ -8,43 +8,43 @@ packages = [{include = "semantic_router"}]
 license = "MIT"
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.13"
-pydantic = "^2.5.3"
+python = ">=3.9,<3.14"
+pydantic = "^2.10.2"
 openai = ">=1.10.0,<2.0.0"
 cohere = {version = ">=5.9.4,<6.00", optional = true}
 mistralai= {version = ">=0.0.12,<0.1.0", optional = true}
 numpy = "^1.25.2"
 colorlog = "^6.8.0"
 pyyaml = "^6.0.1"
+aurelio-sdk = {version = "^0.0.16"}
 pinecone-text = {version = ">=0.7.1,<0.10.0", optional = true}
-torch = {version = ">=2.1.0,<2.6.0", optional = true}
-transformers = {version = ">=4.36.2", optional = true}
-tokenizers = {version = ">=0.19", optional = true}
-llama-cpp-python = {version = ">=0.2.28,<0.2.86", optional = true}
+torch = {version = ">=2.1.0,<2.6.0", optional = true, python = "<3.13" }
+transformers = {version = ">=4.36.2", optional = true, python = "<3.13" }
+tokenizers = {version = ">=0.19", optional = true, python = "<3.13" }
+llama-cpp-python = {version = ">=0.2.28,<0.2.86", optional = true, python = "<3.13" }
 colorama = "^0.4.6"
 pinecone = {version=">=5.0.0", optional = true}
 regex = ">=2023.12.25"
-torchvision = { version = ">=0.17.0,<0.18.0", optional = true}
-pillow = { version = ">=10.2.0,<11.0.0", optional = true}
+torchvision = { version = ">=0.17.0,<0.18.0", optional = true, python = "<3.13" }
+pillow = { version = ">=10.2.0,<11.0.0", optional = true, python = "<3.13" }
 tiktoken = ">=0.6.0,<1.0.0"
-matplotlib = { version = "^3.8.3", optional = true}
 qdrant-client = {version = "^1.11.1", optional = true}
 google-cloud-aiplatform = {version = "^1.45.0", optional = true}
 requests-mock = "^1.12.1"
 boto3 = { version = "^1.34.98", optional = true }
 botocore = {version = "^1.34.110", optional = true}
-aiohttp = "^3.9.5"
-fastembed = {version = "^0.3.0", optional = true}
-psycopg2 = {version = "^2.9.9", optional = true}
+aiohttp = "^3.10.11"
+fastembed = {version = "^0.3.0", optional = true, python = "<3.13" }
+psycopg2-binary = {version = "^2.9.9", optional = true}
 sphinx = {version = "^7.0.0", optional = true}
 sphinxawesome-theme = {version = "^5.2.0", optional = true}
+tornado = {version = "^6.4.2", optional = true}
 
 [tool.poetry.extras]
 hybrid = ["pinecone-text"]
 local = ["torch", "transformers", "tokenizers", "huggingface-hub", "llama-cpp-python"]
 pinecone = ["pinecone"]
 vision = ["torch", "torchvision", "transformers", "pillow"]
-processing = ["matplotlib"]
 mistralai = ["mistralai"]
 qdrant = ["qdrant-client"]
 google = ["google-cloud-aiplatform"]
@@ -57,10 +57,11 @@ cohere = ["cohere"]
 [tool.poetry.group.dev.dependencies]
 ipykernel = "^6.25.0"
 ruff = "^0.1.5"
-pytest = "^7.4.3"
+pytest = "^8.2"
 pytest-mock = "^3.12.0"
 pytest-cov = "^4.1.0"
 pytest-xdist = "^3.5.0"
+pytest-asyncio = "^0.24.0"
 mypy = "^1.7.1"
 types-pyyaml = "^6.0.12.12"
 types-requests = "^2.31.0"

semantic_router-0.1.0.dev3/semantic_router/__init__.py

@@ -0,0 +1,6 @@
+from semantic_router.routers import RouterConfig, SemanticRouter, HybridRouter
+from semantic_router.route import Route
+
+__all__ = ["SemanticRouter", "HybridRouter", "Route", "RouterConfig"]
+
+__version__ = "0.1.0.dev3"

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/__init__.py

@@ -1,6 +1,7 @@
 from typing import List, Optional
 
-from semantic_router.encoders.base import BaseEncoder
+from semantic_router.encoders.aurelio import AurelioSparseEncoder
+from semantic_router.encoders.base import DenseEncoder, SparseEncoder
 from semantic_router.encoders.bedrock import BedrockEncoder
 from semantic_router.encoders.bm25 import BM25Encoder
 from semantic_router.encoders.clip import CLIPEncoder
@@ -14,10 +15,12 @@ from semantic_router.encoders.openai import OpenAIEncoder
 from semantic_router.encoders.tfidf import TfidfEncoder
 from semantic_router.encoders.vit import VitEncoder
 from semantic_router.encoders.zure import AzureOpenAIEncoder
-from semantic_router.schema import EncoderType
+from semantic_router.schema import EncoderType, SparseEmbedding
 
 __all__ = [
-    "BaseEncoder",
+    "AurelioSparseEncoder",
+    "DenseEncoder",
+    "SparseEncoder",
     "AzureOpenAIEncoder",
     "CohereEncoder",
     "OpenAIEncoder",
@@ -37,7 +40,7 @@ __all__ = [
 class AutoEncoder:
     type: EncoderType
     name: Optional[str]
-    model: BaseEncoder
+    model: DenseEncoder | SparseEncoder
 
     def __init__(self, type: str, name: Optional[str]):
         self.type = EncoderType(type)
@@ -49,6 +52,8 @@ class AutoEncoder:
             self.model = CohereEncoder(name=name)
         elif self.type == EncoderType.OPENAI:
             self.model = OpenAIEncoder(name=name)
+        elif self.type == EncoderType.AURELIO:
+            self.model = AurelioSparseEncoder(name=name)
         elif self.type == EncoderType.BM25:
             if name is None:
                 name = "bm25"
@@ -74,5 +79,5 @@ class AutoEncoder:
         else:
             raise ValueError(f"Encoder type '{type}' not supported")
 
-    def __call__(self, texts: List[str]) -> List[List[float]]:
+    def __call__(self, texts: List[str]) -> List[List[float]] | List[SparseEmbedding]:
         return self.model(texts)

semantic_router-0.1.0.dev3/semantic_router/encoders/aurelio.py

@@ -0,0 +1,47 @@
+import os
+from typing import Any, List, Optional
+from pydantic import Field
+
+from aurelio_sdk import AurelioClient, AsyncAurelioClient, EmbeddingResponse
+
+from semantic_router.encoders.base import SparseEncoder
+from semantic_router.schema import SparseEmbedding
+
+
+class AurelioSparseEncoder(SparseEncoder):
+    model: Optional[Any] = None
+    client: AurelioClient = Field(default_factory=AurelioClient, exclude=True)
+    async_client: AsyncAurelioClient = Field(
+        default_factory=AsyncAurelioClient, exclude=True
+    )
+    type: str = "sparse"
+
+    def __init__(
+        self,
+        name: str | None = None,
+        api_key: Optional[str] = None,
+    ):
+        if name is None:
+            name = "bm25"
+        super().__init__(name=name)
+        if api_key is None:
+            api_key = os.getenv("AURELIO_API_KEY")
+        if api_key is None:
+            raise ValueError("AURELIO_API_KEY environment variable is not set.")
+        self.client = AurelioClient(api_key=api_key)
+        self.async_client = AsyncAurelioClient(api_key=api_key)
+
+    def __call__(self, docs: list[str]) -> list[SparseEmbedding]:
+        res: EmbeddingResponse = self.client.embedding(input=docs, model=self.name)
+        embeds = [SparseEmbedding.from_aurelio(r.embedding) for r in res.data]
+        return embeds
+
+    async def acall(self, docs: list[str]) -> list[SparseEmbedding]:
+        res: EmbeddingResponse = await self.async_client.embedding(
+            input=docs, model=self.name
+        )
+        embeds = [SparseEmbedding.from_aurelio(r.embedding) for r in res.data]
+        return embeds
+
+    def fit(self, docs: List[str]):
+        raise NotImplementedError("AurelioSparseEncoder does not support fit.")

semantic_router-0.1.0.dev3/semantic_router/encoders/base.py

@@ -0,0 +1,53 @@
+from typing import Any, Coroutine, List, Optional
+
+from pydantic import BaseModel, Field, field_validator
+import numpy as np
+
+from semantic_router.schema import SparseEmbedding
+
+
+class DenseEncoder(BaseModel):
+    name: str
+    score_threshold: Optional[float] = None
+    type: str = Field(default="base")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    @field_validator("score_threshold")
+    def set_score_threshold(cls, v):
+        return float(v) if v is not None else None
+
+    def __call__(self, docs: List[Any]) -> List[List[float]]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def acall(self, docs: List[Any]) -> Coroutine[Any, Any, List[List[float]]]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+
+class SparseEncoder(BaseModel):
+    name: str
+    type: str = Field(default="base")
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def __call__(self, docs: List[str]) -> List[SparseEmbedding]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    async def acall(self, docs: List[str]) -> list[SparseEmbedding]:
+        raise NotImplementedError("Subclasses must implement this method")
+
+    def _array_to_sparse_embeddings(
+        self, sparse_arrays: np.ndarray
+    ) -> List[SparseEmbedding]:
+        """Consumes several sparse vectors containing zero-values and returns a compact array."""
+        if sparse_arrays.ndim != 2:
+            raise ValueError(f"Expected a 2D array, got a {sparse_arrays.ndim}D array.")
+        # get coordinates of non-zero values
+        coords = np.nonzero(sparse_arrays)
+        # create compact array
+        compact_array = np.array([coords[0], coords[1], sparse_arrays[coords]]).T
+        arr_range = range(compact_array[:, 0].max().astype(int) + 1)
+        arrs = [compact_array[compact_array[:, 0] == i, :][:, 1:3] for i in arr_range]
+        return [SparseEmbedding.from_compact_array(arr) for arr in arrs]

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/bedrock.py

@@ -1,7 +1,7 @@
 """
 This module provides the BedrockEncoder class for generating embeddings using Amazon's Bedrock Platform.
 
-The BedrockEncoder class is a subclass of BaseEncoder and utilizes the TextEmbeddingModel from the
+The BedrockEncoder class is a subclass of DenseEncoder and utilizes the TextEmbeddingModel from the
 Amazon's Bedrock Platform to generate embeddings for given documents. It requires an AWS Access Key ID
 and AWS Secret Access Key and supports customization of the pre-trained model, score threshold, and region.
 
@@ -21,12 +21,12 @@ from typing import List, Optional, Any
 import os
 from time import sleep
 import tiktoken
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.defaults import EncoderDefault
 from semantic_router.utils.logger import logger
 
 
-class BedrockEncoder(BaseEncoder):
+class BedrockEncoder(DenseEncoder):
     client: Any = None
     type: str = "bedrock"
     input_type: Optional[str] = "search_query"

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/bm25.py

@@ -1,21 +1,24 @@
 from typing import Any, Dict, List, Optional
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders.tfidf import TfidfEncoder
 from semantic_router.utils.logger import logger
+from semantic_router.schema import SparseEmbedding
+from semantic_router.route import Route
 
 
-class BM25Encoder(BaseEncoder):
+class BM25Encoder(TfidfEncoder):
     model: Optional[Any] = None
     idx_mapping: Optional[Dict[int, int]] = None
     type: str = "sparse"
 
     def __init__(
         self,
-        name: str = "bm25",
-        score_threshold: float = 0.82,
+        name: str | None = None,
         use_default_params: bool = True,
     ):
-        super().__init__(name=name, score_threshold=score_threshold)
+        if name is None:
+            name = "bm25"
+        super().__init__(name=name)
         try:
             from pinecone_text.sparse import BM25Encoder as encoder
         except ImportError:
@@ -32,6 +35,7 @@ class BM25Encoder(BaseEncoder):
             self._set_idx_mapping()
 
     def _set_idx_mapping(self):
+        # TODO JB: this is training the model somehow - not sure how...
         params = self.model.get_params()
         doc_freq = params["doc_freq"]
         if isinstance(doc_freq, dict):
@@ -40,8 +44,20 @@ class BM25Encoder(BaseEncoder):
         else:
             raise TypeError("Expected a dictionary for 'doc_freq'")
 
-    def __call__(self, docs: List[str]) -> List[List[float]]:
-        if self.model is None or self.idx_mapping is None:
+    def fit(self, routes: List[Route]):
+        """Trains the encoder weights on the provided routes.
+
+        :param routes: List of routes to train the encoder on.
+        :type routes: List[Route]
+        """
+        self._fit_validate(routes=routes)
+        if self.model is None:
+            raise ValueError("Model is not initialized.")
+        utterances = [utterance for route in routes for utterance in route.utterances]
+        self.model.fit(corpus=utterances)
+
+    def __call__(self, docs: List[str]) -> list[SparseEmbedding]:
+        if self.model is None:
             raise ValueError("Model or index mapping is not initialized.")
         if len(docs) == 1:
             sparse_dicts = self.model.encode_queries(docs)
@@ -50,18 +66,8 @@ class BM25Encoder(BaseEncoder):
         else:
             raise ValueError("No documents to encode.")
 
-        embeds = [[0.0] * len(self.idx_mapping)] * len(docs)
+        embeds = []
         for i, output in enumerate(sparse_dicts):
-            indices = output["indices"]
-            values = output["values"]
-            for idx, val in zip(indices, values):
-                if idx in self.idx_mapping:
-                    position = self.idx_mapping[idx]
-                    embeds[i][position] = val
+            if isinstance(output, dict):
+                embeds.append(SparseEmbedding.from_pinecone_dict(output))
         return embeds
-
-    def fit(self, docs: List[str]):
-        if self.model is None:
-            raise ValueError("Model is not initialized.")
-        self.model.fit(docs)
-        self._set_idx_mapping()

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/clip.py

@@ -1,15 +1,14 @@
 from typing import Any, List, Optional
 
 import numpy as np
-from pydantic.v1 import PrivateAttr
+from pydantic import PrivateAttr
 from typing import Dict
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 
 
-class CLIPEncoder(BaseEncoder):
+class CLIPEncoder(DenseEncoder):
     name: str = "openai/clip-vit-base-patch16"
     type: str = "huggingface"
-    score_threshold: float = 0.2
     tokenizer_kwargs: Dict = {}
     processor_kwargs: Dict = {}
     model_kwargs: Dict = {}
@@ -21,6 +20,8 @@ class CLIPEncoder(BaseEncoder):
     _Image: Any = PrivateAttr()
 
     def __init__(self, **data):
+        if data.get("score_threshold") is None:
+            data["score_threshold"] = 0.2
         super().__init__(**data)
         self._tokenizer, self._processor, self._model = self._initialize_hf_model()
 

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/cohere.py

@@ -1,13 +1,13 @@
 import os
 from typing import Any, List, Optional
 
-from pydantic.v1 import PrivateAttr
+from pydantic import PrivateAttr
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.defaults import EncoderDefault
 
 
-class CohereEncoder(BaseEncoder):
+class CohereEncoder(DenseEncoder):
     _client: Any = PrivateAttr()
     _embed_type: Any = PrivateAttr()
     type: str = "cohere"

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/fastembed.py

@@ -1,12 +1,12 @@
 from typing import Any, List, Optional
 
 import numpy as np
-from pydantic.v1 import PrivateAttr
+from pydantic import PrivateAttr
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 
 
-class FastEmbedEncoder(BaseEncoder):
+class FastEmbedEncoder(DenseEncoder):
     type: str = "fastembed"
     name: str = "BAAI/bge-small-en-v1.5"
     max_length: int = 512

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/google.py

@@ -1,7 +1,7 @@
 """
 This module provides the GoogleEncoder class for generating embeddings using Google's AI Platform.
 
-The GoogleEncoder class is a subclass of BaseEncoder and utilizes the TextEmbeddingModel from the
+The GoogleEncoder class is a subclass of DenseEncoder and utilizes the TextEmbeddingModel from the
 Google AI Platform to generate embeddings for given documents. It requires a Google Cloud project ID
 and supports customization of the pre-trained model, score threshold, location, and API endpoint.
 
@@ -19,11 +19,11 @@ Classes:
 import os
 from typing import Any, List, Optional
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.defaults import EncoderDefault
 
 
-class GoogleEncoder(BaseEncoder):
+class GoogleEncoder(DenseEncoder):
     """GoogleEncoder class for generating embeddings using Google's AI Platform.
 
     Attributes:

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/huggingface.py

@@ -1,7 +1,7 @@
 """
 This module provides the HFEndpointEncoder class to embeddings models using Huggingface's endpoint.
 
-The HFEndpointEncoder class is a subclass of BaseEncoder and utilizes a specified Huggingface 
+The HFEndpointEncoder class is a subclass of DenseEncoder and utilizes a specified Huggingface 
 endpoint to generate embeddings for given documents. It requires the URL of the Huggingface 
 API endpoint and an API key for authentication. The class supports customization of the score 
 threshold for filtering or processing the embeddings.
@@ -25,16 +25,15 @@ import time
 import os
 from typing import Any, List, Optional, Dict
 
-from pydantic.v1 import PrivateAttr
+from pydantic import PrivateAttr
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.logger import logger
 
 
-class HuggingFaceEncoder(BaseEncoder):
+class HuggingFaceEncoder(DenseEncoder):
     name: str = "sentence-transformers/all-MiniLM-L6-v2"
     type: str = "huggingface"
-    score_threshold: float = 0.5
     tokenizer_kwargs: Dict = {}
     model_kwargs: Dict = {}
     device: Optional[str] = None
@@ -43,6 +42,8 @@ class HuggingFaceEncoder(BaseEncoder):
     _torch: Any = PrivateAttr()
 
     def __init__(self, **data):
+        if data.get("score_threshold") is None:
+            data["score_threshold"] = 0.5
         super().__init__(**data)
         self._tokenizer, self._model = self._initialize_hf_model()
 
@@ -140,7 +141,7 @@ class HuggingFaceEncoder(BaseEncoder):
         return self._torch.max(token_embeddings, 1)[0]
 
 
-class HFEndpointEncoder(BaseEncoder):
+class HFEndpointEncoder(DenseEncoder):
     """
     A class to encode documents using a Hugging Face transformer model endpoint.
 
@@ -153,7 +154,6 @@ class HFEndpointEncoder(BaseEncoder):
     name: str = "hugging_face_custom_endpoint"
     huggingface_url: Optional[str] = None
     huggingface_api_key: Optional[str] = None
-    score_threshold: float = 0.8
 
     def __init__(
         self,
@@ -180,6 +180,8 @@ class HFEndpointEncoder(BaseEncoder):
         """
         huggingface_url = huggingface_url or os.getenv("HF_API_URL")
         huggingface_api_key = huggingface_api_key or os.getenv("HF_API_KEY")
+        if score_threshold is None:
+            score_threshold = 0.8
 
         super().__init__(name=name, score_threshold=score_threshold)  # type: ignore
 

{semantic_router-0.1.0.dev1 → semantic_router-0.1.0.dev3}/semantic_router/encoders/mistral.py

@@ -4,13 +4,13 @@ import os
 from time import sleep
 from typing import Any, List, Optional
 
-from pydantic.v1 import PrivateAttr
+from pydantic import PrivateAttr
 
-from semantic_router.encoders import BaseEncoder
+from semantic_router.encoders import DenseEncoder
 from semantic_router.utils.defaults import EncoderDefault
 
 
-class MistralEncoder(BaseEncoder):
+class MistralEncoder(DenseEncoder):
     """Class to encode text using MistralAI"""
 
     _client: Any = PrivateAttr()