semantic-router 0.1.0.dev8__tar.gz → 0.1.0.dev10__tar.gz

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: semantic-router
-Version: 0.1.0.dev8
+Version: 0.1.0.dev10
 Summary: Super fast semantic router for AI decision making
 License: MIT
 Author: Aurelio AI
@@ -26,7 +26,7 @@ Provides-Extra: postgres
 Provides-Extra: qdrant
 Provides-Extra: vision
 Requires-Dist: aiohttp (>=3.10.11,<4.0.0)
-Requires-Dist: aurelio-sdk (>=0.0.16,<0.0.17)
+Requires-Dist: aurelio-sdk (>=0.0.18,<0.0.19)
 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"

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "semantic-router"
-version = "0.1.0.dev8"
+version = "0.1.0.dev10"
 description = "Super fast semantic router for AI decision making"
 authors = ["Aurelio AI <hello@aurelio.ai>"]
 readme = "README.md"
@@ -16,7 +16,7 @@ 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"}
+aurelio-sdk = {version = "^0.0.18"}
 pinecone-text = {version = ">=0.7.1", 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" }

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/semantic_router/__init__.py

@@ -3,4 +3,4 @@ from semantic_router.routers import HybridRouter, RouterConfig, SemanticRouter
 
 __all__ = ["SemanticRouter", "HybridRouter", "Route", "RouterConfig"]
 
-__version__ = "0.1.0.dev8"
+__version__ = "0.1.0.dev10"

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/semantic_router/index/pinecone.py

@@ -3,6 +3,8 @@ import hashlib
 import json
 import os
 import time
+import requests
+from json.decoder import JSONDecodeError
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import aiohttp
@@ -18,6 +20,13 @@ def clean_route_name(route_name: str) -> str:
     return route_name.strip().replace(" ", "-")
 
 
+class DeleteRequest(BaseModel):
+    ids: list[str] | None = None
+    delete_all: bool = False
+    namespace: str | None = None
+    filter: dict[str, Any] | None = None
+
+
 def build_records(
     embeddings: List[List[float]],
     routes: List[str],
@@ -114,8 +123,9 @@ class PineconeIndex(BaseIndex):
     index: Optional[Any] = Field(default=None, exclude=True)
     ServerlessSpec: Any = Field(default=None, exclude=True)
     namespace: Optional[str] = ""
-    base_url: Optional[str] = "https://api.pinecone.io"
+    base_url: Optional[str] = None
     headers: dict[str, str] = {}
+    index_host: Optional[str] = "http://localhost:5080"
 
     def __init__(
         self,
@@ -134,12 +144,23 @@ class PineconeIndex(BaseIndex):
         self.api_key = api_key or os.getenv("PINECONE_API_KEY")
         if not self.api_key:
             raise ValueError("Pinecone API key is required.")
+
         self.headers = {
             "Api-Key": self.api_key,
             "Content-Type": "application/json",
-            "X-Pinecone-API-Version": "2024-07",
             "User-Agent": "source_tag=semanticrouter",
         }
+
+        if base_url is not None or os.getenv("PINECONE_API_BASE_URL"):
+            logger.info("Using pinecone remote API.")
+            if os.getenv("PINECONE_API_BASE_URL"):
+                self.base_url = os.getenv("PINECONE_API_BASE_URL")
+            else:
+                self.base_url = base_url
+
+        if self.base_url and "api.pinecone.io" in self.base_url:
+            self.headers["X-Pinecone-API-Version"] = "2024-07"
+
         self.index_name = index_name
         self.dimensions = dimensions
         self.metric = metric
@@ -150,16 +171,11 @@ class PineconeIndex(BaseIndex):
             raise ValueError("Namespace 'sr_config' is reserved for internal use.")
         self.namespace = namespace
         self.type = "pinecone"
-        self.api_key = api_key or os.getenv("PINECONE_API_KEY")
-        self.base_url = base_url
 
         logger.warning(
             "Default region changed from us-west-2 to us-east-1 in v0.1.0.dev6"
         )
 
-        if self.api_key is None:
-            raise ValueError("Pinecone API key is required.")
-
         self.client = self._initialize_client(api_key=self.api_key)
 
         # try initializing index
@@ -186,6 +202,20 @@ class PineconeIndex(BaseIndex):
 
         return Pinecone(**pinecone_args)
 
+    def _calculate_index_host(self):
+        if self.index_host and self.base_url:
+            if "api.pinecone.io" in self.base_url:
+                if not self.index_host.startswith("http"):
+                    self.index_host = f"https://{self.index_host}"
+            else:
+                if "http" not in self.index_host:
+                    self.index_host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.index_host.split(':')[-1]}"
+                elif not self.index_host.startswith("http://"):
+                    if "localhost" in self.index_host:
+                        self.index_host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.index_host.split(':')[-1]}"
+                    else:
+                        self.index_host = f"http://{self.index_host}"
+
     def _init_index(self, force_create: bool = False) -> Union[Any, None]:
         """Initializing the index can be done after the object has been created
         to allow for the user to set the dimensions and other parameters.
@@ -199,43 +229,59 @@ class PineconeIndex(BaseIndex):
             dimensions are not given (which will raise an error).
         :type force_create: bool, optional
         """
-        index_exists = self.index_name in self.client.list_indexes().names()
         dimensions_given = self.dimensions is not None
-        if dimensions_given and not index_exists:
-            # if the index doesn't exist and we have dimension value
-            # we create the index
-            self.client.create_index(
-                name=self.index_name,
-                dimension=self.dimensions,
-                metric=self.metric,
-                spec=self.ServerlessSpec(cloud=self.cloud, region=self.region),
-            )
-            # wait for index to be created
-            while not self.client.describe_index(self.index_name).status["ready"]:
-                time.sleep(1)
-            index = self.client.Index(self.index_name)
-            time.sleep(0.5)
-        elif index_exists:
-            # if the index exists we just return it
-            index = self.client.Index(self.index_name)
-            # grab the dimensions from the index
-            self.dimensions = index.describe_index_stats()["dimension"]
-        elif force_create and not dimensions_given:
-            raise ValueError(
-                "Cannot create an index without specifying the dimensions."
-            )
+        if self.index is None:
+            index_exists = self.index_name in self.client.list_indexes().names()
+            if dimensions_given and not index_exists:
+                # if the index doesn't exist and we have dimension value
+                # we create the index
+                self.client.create_index(
+                    name=self.index_name,
+                    dimension=self.dimensions,
+                    metric=self.metric,
+                    spec=self.ServerlessSpec(cloud=self.cloud, region=self.region),
+                )
+                # wait for index to be created
+                while not self.client.describe_index(self.index_name).status["ready"]:
+                    time.sleep(0.2)
+                index = self.client.Index(self.index_name)
+                self.index = index
+                time.sleep(0.2)
+            elif index_exists:
+                # if the index exists we just return it
+                # index = self.client.Index(self.index_name)
+
+                self.index_host = self.client.describe_index(self.index_name).host
+                self._calculate_index_host()
+                index = self.client.Index(self.index_name, host=self.index_host)
+                self.index = index
+
+                # grab the dimensions from the index
+                self.dimensions = index.describe_index_stats()["dimension"]
+            elif force_create and not dimensions_given:
+                raise ValueError(
+                    "Cannot create an index without specifying the dimensions."
+                )
+            else:
+                # if the index doesn't exist and we don't have the dimensions
+                # we return None
+                logger.warning(
+                    "Index could not be initialized. Init parameters: "
+                    f"{self.index_name=}, {self.dimensions=}, {self.metric=}, "
+                    f"{self.cloud=}, {self.region=}, {self.host=}, {self.namespace=}, "
+                    f"{force_create=}"
+                )
+                index = None
         else:
-            # if the index doesn't exist and we don't have the dimensions
-            # we return None
-            logger.warning(
-                "Index could not be initialized. Init parameters: "
-                f"{self.index_name=}, {self.dimensions=}, {self.metric=}, "
-                f"{self.cloud=}, {self.region=}, {self.host=}, {self.namespace=}, "
-                f"{force_create=}"
-            )
-            index = None
-        if index is not None:
-            self.host = self.client.describe_index(self.index_name)["host"]
+            index = self.index
+        if self.index is not None and self.host == "":
+            # if the index exists we just return it
+            self.index_host = self.client.describe_index(self.index_name).host
+
+            if self.index_host and self.base_url:
+                self._calculate_index_host()
+                index = self.client.Index(self.index_name, host=self.index_host)
+                self.host = self.index_host
         return index
 
     async def _init_async_index(self, force_create: bool = False):
@@ -442,12 +488,37 @@ class PineconeIndex(BaseIndex):
     def delete(self, route_name: str):
         route_vec_ids = self._get_route_ids(route_name=route_name)
         if self.index is not None:
-            self.index.delete(ids=route_vec_ids, namespace=self.namespace)
+            logger.info("index is not None, deleting...")
+            if self.base_url and "api.pinecone.io" in self.base_url:
+                self.index.delete(ids=route_vec_ids, namespace=self.namespace)
+            else:
+
+                response = requests.post(
+                    f"{self.index_host}/vectors/delete",
+                    json=DeleteRequest(
+                        ids=route_vec_ids,
+                        delete_all=True,
+                        namespace=self.namespace,
+                    ).model_dump(exclude_none=True),
+                    timeout=10,
+                )
+                if response.status_code == 200:
+                    logger.info(
+                        f"Deleted {len(route_vec_ids)} vectors from index {self.index_name}."
+                    )
+                else:
+                    error_message = response.text
+                    raise Exception(
+                        f"Failed to delete vectors: {response.status_code} : {error_message}"
+                    )
         else:
             raise ValueError("Index is None, could not delete.")
 
     def delete_all(self):
-        self.index.delete(delete_all=True, namespace=self.namespace)
+        if self.index is not None:
+            self.index.delete(delete_all=True, namespace=self.namespace)
+        else:
+            raise ValueError("Index is None, could not delete.")
 
     def describe(self) -> IndexConfig:
         if self.index is not None:
@@ -501,19 +572,31 @@ class PineconeIndex(BaseIndex):
         else:
             filter_query = None
         if sparse_vector is not None:
+            logger.error(f"sparse_vector exists:{sparse_vector}")
             if isinstance(sparse_vector, dict):
                 sparse_vector = SparseEmbedding.from_dict(sparse_vector)
             if isinstance(sparse_vector, SparseEmbedding):
                 # unnecessary if-statement but mypy didn't like this otherwise
                 sparse_vector = sparse_vector.to_pinecone()
-        results = self.index.query(
-            vector=[query_vector_list],
-            sparse_vector=sparse_vector,
-            top_k=top_k,
-            filter=filter_query,
-            include_metadata=True,
-            namespace=self.namespace,
-        )
+        try:
+            results = self.index.query(
+                vector=[query_vector_list],
+                sparse_vector=sparse_vector,
+                top_k=top_k,
+                filter=filter_query,
+                include_metadata=True,
+                namespace=self.namespace,
+            )
+        except Exception:
+            logger.error("retrying query with vector as str")
+            results = self.index.query(
+                vector=query_vector_list,
+                sparse_vector=sparse_vector,
+                top_k=top_k,
+                filter=filter_query,
+                include_metadata=True,
+                namespace=self.namespace,
+            )
         scores = [result["score"] for result in results["matches"]]
         route_names = [result["metadata"]["sr_route"] for result in results["matches"]]
         return np.array(scores), route_names
@@ -710,16 +793,35 @@ class PineconeIndex(BaseIndex):
             "filter": filter,
             "top_k": top_k,
             "include_metadata": include_metadata,
+            "topK": top_k,
+            "includeMetadata": include_metadata,
         }
         if self.host == "":
             raise ValueError("self.host is not initialized.")
+        elif self.base_url and "api.pinecone.io" in self.base_url:
+            if not self.host.startswith("http"):
+                logger.error(f"host exists:{self.host}")
+
+                self.host = f"https://{self.host}"
+        elif self.host.startswith("localhost") and self.base_url:
+            self.host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.host.split(':')[-1]}"
+
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"https://{self.host}/query",
+                f"{self.host}/query",
                 json=params,
                 headers=self.headers,
             ) as response:
-                return await response.json(content_type=None)
+                if response.status != 200:
+                    error_text = await response.text()
+                    logger.error(f"Error in query response: {error_text}")
+                    return {}  # or handle the error as needed
+
+                try:
+                    return await response.json(content_type=None)
+                except JSONDecodeError as e:
+                    logger.error(f"JSON decode error: {e}")
+                    return {}
 
     async def _async_list_indexes(self):
         async with aiohttp.ClientSession() as session:
@@ -738,9 +840,17 @@ class PineconeIndex(BaseIndex):
             "vectors": vectors,
             "namespace": namespace,
         }
+
+        if self.base_url and "api.pinecone.io" in self.base_url:
+            if not self.host.startswith("http"):
+                logger.error(f"host exists:{self.host}")
+                self.host = f"https://{self.host}"
+
+        elif self.host.startswith("localhost") and self.base_url:
+            self.host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.host.split(':')[-1]}"
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"https://{self.host}/vectors/upsert",
+                f"{self.host}/vectors/upsert",
                 json=params,
                 headers=self.headers,
             ) as response:
@@ -774,9 +884,16 @@ class PineconeIndex(BaseIndex):
             "ids": ids,
             "namespace": namespace,
         }
+        if self.base_url and "api.pinecone.io" in self.base_url:
+            if not self.host.startswith("http"):
+                logger.error(f"host exists:{self.host}")
+                self.host = f"https://{self.host}"
+        elif self.host.startswith("localhost") and self.base_url:
+            self.host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.host.split(':')[-1]}"
+
         async with aiohttp.ClientSession() as session:
             async with session.post(
-                f"https://{self.host}/vectors/delete",
+                f"{self.host}/vectors/delete",
                 json=params,
                 headers=self.headers,
             ) as response:
@@ -816,7 +933,15 @@ class PineconeIndex(BaseIndex):
         else:
             prefix_str = ""
 
-        list_url = f"https://{self.host}/vectors/list{prefix_str}"
+        if self.base_url and "api.pinecone.io" in self.base_url:
+            if not self.host.startswith("http"):
+                logger.error(f"host exists:{self.host}")
+                self.host = f"https://{self.host}"
+
+        elif self.host.startswith("localhost") and self.base_url:
+            self.host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.host.split(':')[-1]}"
+
+        list_url = f"{self.host}/vectors/list{prefix_str}"
         params: dict = {}
         if self.namespace:
             params["namespace"] = self.namespace
@@ -874,7 +999,14 @@ class PineconeIndex(BaseIndex):
         """
         if self.host == "":
             raise ValueError("self.host is not initialized.")
-        url = f"https://{self.host}/vectors/fetch"
+        if self.base_url and "api.pinecone.io" in self.base_url:
+            if not self.host.startswith("http"):
+                logger.error(f"host exists:{self.host}")
+                self.host = f"https://{self.host}"
+        elif self.host.startswith("localhost") and self.base_url:
+            self.host = f"http://{self.base_url.split(':')[-2].strip('/')}:{self.host.split(':')[-1]}"
+
+        url = f"{self.host}/vectors/fetch"
 
         params = {
             "ids": [vector_id],

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/semantic_router/routers/base.py

@@ -397,7 +397,11 @@ class BaseRouter(BaseModel):
             self.index.dimensions = dims
         # now init index
         if isinstance(self.index, PineconeIndex):
+            # _init_index will not create index if already exists — it will also check
+            # for required attributes like self.index.host and self.index.dimensions and
+            # fetch them if not set
             self.index.index = self.index._init_index(force_create=True)
+
         # run auto sync if active
         if self.auto_sync:
             local_utterances = self.to_config().to_utterances()
@@ -1086,7 +1090,11 @@ class BaseRouter(BaseModel):
         route_names = [route.name for route in routes for _ in route.utterances]
         utterances = [utterance for route in routes for utterance in route.utterances]
         function_schemas = [
-            route.function_schemas[0] if route.function_schemas is not None else {}
+            (
+                route.function_schemas[0]
+                if route.function_schemas and len(route.function_schemas) > 0
+                else {}
+            )
             for route in routes
             for _ in route.utterances
         ]

{semantic_router-0.1.0.dev8 → semantic_router-0.1.0.dev10}/semantic_router/schema.py

@@ -5,10 +5,10 @@ from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
-from aurelio_sdk.schema import BM25Embedding
 from pydantic import BaseModel, Field
 
 from semantic_router.utils.logger import logger
+from aurelio_sdk.schema import SparseEmbedding as BM25SparseEmbedding
 
 
 class EncoderType(Enum):
@@ -450,7 +450,7 @@ class SparseEmbedding(BaseModel):
         return cls.from_compact_array(np.array([np.arange(len(vector)), vector]).T)
 
     @classmethod
-    def from_aurelio(cls, embedding: BM25Embedding):
+    def from_aurelio(cls, embedding: BM25SparseEmbedding):
         arr = np.array([embedding.indices, embedding.values]).T
         return cls.from_compact_array(arr)