feature: adding pinecone namespace

d36be55f · the-anup-das · 103a5e88 · d36be55f · d36be55f · d36be55f
Commit d36be55f authored 11 months ago by the-anup-das
--- a/docs/09-route-filter.ipynb
+++ b/docs/09-route-filter.ipynb
@@ -41,7 +41,7 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "!pip install -qU semantic-router==0.0.32\n"
+    "!pip install -qU semantic-router==0.0.32"
   ]
  },
  {
@@ -124,6 +124,7 @@
    "import os\n",
    "from getpass import getpass\n",
    "from semantic_router.encoders import CohereEncoder, OpenAIEncoder\n",
+    "\n",
    "os.environ[\"COHERE_API_KEY\"] = os.getenv(\"COHERE_API_KEY\") or getpass(\n",
    "    \"Enter Cohere API Key: \"\n",
    ")\n",
@@ -259,7 +260,7 @@
    }
   ],
   "source": [
-    "rl(\"don't you love politics?\", route_filter=[\"chitchat\"])\n"
+    "rl(\"don't you love politics?\", route_filter=[\"chitchat\"])"
   ]
  },
  {
@@ -288,7 +289,7 @@
    }
   ],
   "source": [
-    "rl(\"how's the weather today?\", route_filter=[\"politics\"])\n"
+    "rl(\"how's the weather today?\", route_filter=[\"politics\"])"
   ]
  },
  {

 %% Cell type:markdown id: tags:
 [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/aurelio-labs/semantic-router/blob/main/docs/09-route-filter.ipynb) [![Open nbviewer](https://raw.githubusercontent.com/pinecone-io/examples/master/assets/nbviewer-shield.svg)](https://nbviewer.org/github/aurelio-labs/semantic-router/blob/main/docs/00-introduction.ipynb)
 %% Cell type:markdown id: tags:
 # Semantic Router Filter
 %% Cell type:markdown id: tags:
 The Semantic Router library can be used as a super fast route making layer on top of LLMs. That means rather than waiting on a slow agent to decide what to do, we can use the magic of semantic vector space to make routes. Cutting route making time down from seconds to milliseconds.
 %% Cell type:markdown id: tags:
 ## Getting Started
 %% Cell type:markdown id: tags:
 We start by installing the library:
 %% Cell type:code id: tags:
 ``` python
 !pip install -qU semantic-router==0.0.32
 ```
 %% Cell type:markdown id: tags:
 We start by defining a dictionary mapping routes to example phrases that should trigger those routes.
 %% Cell type:code id: tags:
 ``` python
 from semantic_router import Route
 politics = Route(
    name="politics",
    utterances=[
        "isn't politics the best thing ever",
        "why don't you tell me about your political opinions",
        "don't you just love the president",
        "don't you just hate the president",
        "they're going to destroy this country!",
        "they will save the country!",
    ],
 )
 ```
 %% Output
    /Users/zahidsyed/anaconda3/envs/semantic_router/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html
      from .autonotebook import tqdm as notebook_tqdm
 %% Cell type:markdown id: tags:
 Let's define another for good measure:
 %% Cell type:code id: tags:
 ``` python
 chitchat = Route(
    name="chitchat",
    utterances=[
        "how's the weather today?",
        "how are things going?",
        "lovely weather today",
        "the weather is horrendous",
        "let's go to the chippy",
    ],
 )
 routes = [politics, chitchat]
 ```
 %% Cell type:markdown id: tags:
 Now we initialize our embedding model:
 %% Cell type:code id: tags:
 ``` python
 import os
 from getpass import getpass
 from semantic_router.encoders import CohereEncoder, OpenAIEncoder
 os.environ["COHERE_API_KEY"] = os.getenv("COHERE_API_KEY") or getpass(
    "Enter Cohere API Key: "
 )
 # os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY") or getpass(
 #     "Enter OpenAI API Key: "
 # )
 encoder = CohereEncoder()
 # encoder = OpenAIEncoder()
 ```
 %% Cell type:markdown id: tags:
 Now we define the `RouteLayer`. When called, the route layer will consume text (a query) and output the category (`Route`) it belongs to — to initialize a `RouteLayer` we need our `encoder` model and a list of `routes`.
 %% Cell type:code id: tags:
 ``` python
 from semantic_router.layer import RouteLayer
 rl = RouteLayer(encoder=encoder, routes=routes)
 ```
 %% Output
    [32m2024-03-28 14:24:37 INFO semantic_router.utils.logger local[0m
 %% Cell type:markdown id: tags:
 Now we can test it:
 %% Cell type:code id: tags:
 ``` python
 rl("don't you love politics?")
 ```
 %% Output
    RouteChoice(name='politics', function_call=None, similarity_score=None)
 %% Cell type:code id: tags:
 ``` python
 rl("how's the weather today?")
 ```
 %% Cell type:markdown id: tags:
 Both are classified accurately, what if we send a query that is unrelated to our existing `Route` objects?
 %% Cell type:code id: tags:
 ``` python
 rl("I'm interested in learning about llama 2")
 ```
 %% Output
    RouteChoice(name=None, function_call=None, similarity_score=None)
 %% Cell type:markdown id: tags:
 In this case, we return `None` because no matches were identified.
 %% Cell type:markdown id: tags:
 # Demonstrating the Filter Feature
 Now, let's demonstrate the filter feature. We can specify a subset of routes to consider when making a classification. This can be useful if we want to restrict the scope of possible routes based on some context.
 For example, let's say we only want to consider the "chitchat" route for a particular query:
 %% Cell type:code id: tags:
 ``` python
 rl("don't you love politics?", route_filter=["chitchat"])
 ```
 %% Output
    RouteChoice(name='chitchat', function_call=None, similarity_score=None)
 %% Cell type:markdown id: tags:
 Even though the query might be more related to the "politics" route, it will be classified as "chitchat" because we've restricted the routes to consider.
 Similarly, we can restrict it to the "politics" route:
 %% Cell type:code id: tags:
 ``` python
 rl("how's the weather today?", route_filter=["politics"])
 ```
 %% Output
    RouteChoice(name=None, function_call=None, similarity_score=None)
 %% Cell type:markdown id: tags:
 In this case, it will return None because the query doesn't match the "politics" route well enough to pass the threshold.

--- a/docs/examples/pinecone-and-scaling.ipynb
+++ b/docs/examples/pinecone-and-scaling.ipynb
--- a/docs/indexes/qdrant.ipynb
+++ b/docs/indexes/qdrant.ipynb
@@ -55,6 +55,7 @@
    "import os\n",
    "from getpass import getpass\n",
    "from semantic_router.encoders import CohereEncoder\n",
+    "\n",
    "os.environ[\"COHERE_API_KEY\"] = os.environ.get(\"COHERE_API_KEY\") or getpass(\n",
    "    \"Enter COHERE API key: \"\n",
    ")\n",

 %% Cell type:code id: tags:
 ``` python
 !pip install -qU "semantic-router[qdrant]"
 ```
 %% Cell type:code id: tags:
 ``` python
 from semantic_router import Route
 # we could use this as a guide for our chatbot to avoid political conversations
 politics = Route(
    name="politics",
    utterances=[
        "isn't politics the best thing ever",
        "why don't you tell me about your political opinions",
        "don't you just love the president" "don't you just hate the president",
        "they're going to destroy this country!",
        "they will save the country!",
    ],
 )
 # this could be used as an indicator to our chatbot to switch to a more
 # conversational prompt
 chitchat = Route(
    name="chitchat",
    utterances=[
        "how's the weather today?",
        "how are things going?",
        "lovely weather today",
        "the weather is horrendous",
        "let's go to the chippy",
    ],
 )
 # we place both of our decisions together into single list
 routes = [politics, chitchat]
 ```
 %% Cell type:code id: tags:
 ``` python
 import os
 from getpass import getpass
 from semantic_router.encoders import CohereEncoder
 os.environ["COHERE_API_KEY"] = os.environ.get("COHERE_API_KEY") or getpass(
    "Enter COHERE API key: "
 )
 encoder = CohereEncoder()
 ```
 %% Cell type:code id: tags:
 ``` python
 from semantic_router.index.qdrant import QdrantIndex
 qd_index = QdrantIndex(location=":memory:")
 ```
 %% Cell type:code id: tags:
 ``` python
 from semantic_router.layer import RouteLayer
 rl = RouteLayer(encoder=encoder, routes=routes, index=qd_index)
 ```
 %% Output
    [32m2024-03-27 18:22:42 INFO semantic_router.utils.logger local[0m
 %% Cell type:markdown id: tags:
 We can check our route layer and index information.
 %% Cell type:code id: tags:
 ``` python
 rl.list_route_names()
 ```
 %% Output
    ['politics', 'chitchat']
 %% Cell type:code id: tags:
 ``` python
 len(rl.index)
 ```
 %% Output
    10
 %% Cell type:markdown id: tags:
 And query:
 %% Cell type:code id: tags:
 ``` python
 rl("don't you love politics?").name
 ```
 %% Output
    'politics'
 %% Cell type:code id: tags:
 ``` python
 rl("how's the weather today?").name
 ```
 %% Output
    'chitchat'
 %% Cell type:code id: tags:
 ``` python
 rl("I'm interested in learning about llama 2").name
 ```
 %% Cell type:markdown id: tags:
 We can delete or update routes.
 %% Cell type:code id: tags:
 ``` python
 len(rl.index)
 ```
 %% Output
    10
 %% Cell type:code id: tags:
 ``` python
 import time
 rl.delete(route_name="chitchat")
 time.sleep(1)
 len(rl.index)
 ```
 %% Output
    5
 %% Cell type:code id: tags:
 ``` python
 rl("how's the weather today?").name
 ```
 %% Cell type:code id: tags:
 ``` python
 rl.index.get_routes()
 ```
 %% Output
    [('politics', 'they will save the country!'),
     ('politics', "isn't politics the best thing ever"),
     ('politics', "why don't you tell me about your political opinions"),
     ('politics', "they're going to destroy this country!"),
     ('politics',
      "don't you just love the presidentdon't you just hate the president")]
 %% Cell type:code id: tags:
 ``` python
 rl.index.describe()
 ```
 %% Output
    {'type': 'qdrant', 'dimensions': 1024, 'vectors': 5}

--- a/semantic_router/encoders/tfidf.py
+++ b/semantic_router/encoders/tfidf.py
@@ -35,7 +35,7 @@ class TfidfEncoder(BaseEncoder):
        docs = []
        for route in routes:
            for doc in route.utterances:
-                docs.append(self._preprocess(doc))
+                docs.append(self._preprocess(doc))  # type: ignore
        self.word_index = self._build_word_index(docs)
        self.idf = self._compute_idf(docs)

--- a/semantic_router/index/pinecone.py
+++ b/semantic_router/index/pinecone.py
@@ -47,12 +47,14 @@ class PineconeIndex(BaseIndex):
    client: Any = Field(default=None, exclude=True)
    index: Optional[Any] = Field(default=None, exclude=True)
    ServerlessSpec: Any = Field(default=None, exclude=True)
+    namespace: Optional[str] = ""
    def __init__(self, **data):
        super().__init__(**data)
        self._initialize_client()
        self.type = "pinecone"
        self.client = self._initialize_client()
+        self.index = self._init_index(force_create=True)
    def _initialize_client(self, api_key: Optional[str] = None):
        try:
@@ -68,7 +70,11 @@ class PineconeIndex(BaseIndex):
        api_key = api_key or os.getenv("PINECONE_API_KEY")
        if api_key is None:
            raise ValueError("Pinecone API key is required.")
-        return Pinecone(api_key=api_key, source_tag="semantic-router")
+        pinecone_args = {"api_key": api_key, "source_tag": "semantic-router"}
+        if self.namespace:
+            pinecone_args["namespace"] = self.namespace
+        return Pinecone(**pinecone_args)
    def _init_index(self, force_create: bool = False) -> Union[Any, None]:
        index_exists = self.index_name in self.client.list_indexes().names()
@@ -89,7 +95,7 @@ class PineconeIndex(BaseIndex):
            time.sleep(0.5)
        elif index_exists:
            # if the index exists we just return it
-            index = self.client.Index(self.index_name)
+            index = self.client.Index(self.index_name, namespace=self.namespace)
            # grab the dimensions from the index
            self.dimensions = index.describe_index_stats()["dimension"]
        elif force_create and not dimensions_given:
@@ -108,7 +114,7 @@ class PineconeIndex(BaseIndex):
    def _batch_upsert(self, batch: List[dict]):
        """Helper method for upserting a single batch of records."""
        if self.index is not None:
-            self.index.upsert(vectors=batch)
+            self.index.upsert(vectors=batch, namespace=self.namespace)
        else:
            raise ValueError("Index is None, could not upsert.")
@@ -175,7 +181,7 @@ class PineconeIndex(BaseIndex):
            # if we need metadata, we fetch it
            if include_metadata:
-                res_meta = self.index.fetch(ids=vector_ids)
+                res_meta = self.index.fetch(ids=vector_ids, namespace=self.namespace)
                # extract metadata only
                metadata.extend([x["metadata"] for x in res_meta["vectors"].values()])
@@ -206,7 +212,7 @@ class PineconeIndex(BaseIndex):
            raise ValueError("Index is None, could not delete.")
    def delete_all(self):
-        self.index.delete(delete_all=True)
+        self.index.delete(delete_all=True, namespace=self.namespace)
    def describe(self) -> dict:
        if self.index is not None:
@@ -237,6 +243,7 @@ class PineconeIndex(BaseIndex):
            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"]]

--- a/semantic_router/layer.py
+++ b/semantic_router/layer.py
@@ -328,7 +328,7 @@ class RouteLayer:
    def add(self, route: Route):
        logger.info(f"Adding `{route.name}` route")
        # create embeddings
-        embeds = self.encoder(route.utterances)
+        embeds = self.encoder(route.utterances)  # type:ignore
        # if route has no score_threshold, use default
        if route.score_threshold is None:
            route.score_threshold = self.score_threshold
@@ -337,7 +337,7 @@ class RouteLayer:
        self.index.add(
            embeddings=embeds,
            routes=[route.name] * len(route.utterances),
-            utterances=route.utterances,
+            utterances=route.utterances,  # type:ignore
        )
        self.routes.append(route)
@@ -383,14 +383,14 @@ class RouteLayer:
        all_utterances = [
            utterance for route in routes for utterance in route.utterances
        ]
-        embedded_utterances = self.encoder(all_utterances)
+        embedded_utterances = self.encoder(all_utterances)  # type:ignore
        # create route array
        route_names = [route.name for route in routes for _ in route.utterances]
        # add everything to the index
        self.index.add(
            embeddings=embedded_utterances,
            routes=route_names,
-            utterances=all_utterances,
+            utterances=all_utterances,  # type:ignore
        )
    def _encode(self, text: str) -> Any: