restructure and tweaks

.gitignore

 .env
 mac.env
+.DS_Store
 
 **/__pycache__
+**/*.py[cod]
\ No newline at end of file

decision_layer/__init__.py

-from decision_layer.decision_layer import DecisionLayer
\ No newline at end of file

decision_layer/encoders/__init__.py

-from decision_layer.encoders.base import BaseEncoder
-from decision_layer.encoders.cohere import CohereEncoder
-from decision_layer.encoders.huggingface import HuggingFaceEncoder
-from decision_layer.encoders.openai import OpenAIEncoder
\ No newline at end of file

pyproject.toml

 [tool.poetry]
-name = "decision-layer"
+name = "semantic-router"
 version = "0.0.1"
-description = "Super fast decision layer for AI"
-authors = ["James Briggs <james@aurelio.ai>"]
+description = "Super fast semantic router for AI decision making"
+authors = [
+    "James Briggs <james@aurelio.ai>",
+    "Siraj Aizlewood <siraj@aurelio.ai>"
+]
 readme = "README.md"
 
 [tool.poetry.dependencies]

semantic_router/__init__.py

+from semantic_router.layer import DecisionLayer
\ No newline at end of file

semantic_router/encoders/__init__.py

+from semantic_router.encoders.base import BaseEncoder
+from semantic_router.encoders.cohere import CohereEncoder
+from semantic_router.encoders.huggingface import HuggingFaceEncoder
+from semantic_router.encoders.openai import OpenAIEncoder
\ No newline at end of file

decision_layer/encoders/cohere.py → semantic_router/encoders/cohere.py

 import os
 import cohere
-from decision_layer.encoders import BaseEncoder
+from semantic_router.encoders import BaseEncoder
 
 class CohereEncoder(BaseEncoder):
     client: cohere.Client | None
-    def __init__(self, name: str, cohere_api_key: str | None = None):
+    def __init__(self, name: str = "embed-english-v3.0", cohere_api_key: str | None = None):
         super().__init__(name=name, client=None)
         cohere_api_key = cohere_api_key or os.getenv("COHERE_API_KEY")
         if cohere_api_key is None:
@@ -17,6 +17,6 @@ class CohereEncoder(BaseEncoder):
         else:
             input_type = "search_document"
         embeds = self.client.embed(
-            texts, input_type=input_type, model="embed-english-v3.0"
+            texts, input_type=input_type, model=self.name
         )
         return embeds.embeddings
\ No newline at end of file

decision_layer/encoders/huggingface.py → semantic_router/encoders/huggingface.py

-from decision_layer.encoders import BaseEncoder
+from semantic_router.encoders import BaseEncoder
 
 
 class HuggingFaceEncoder(BaseEncoder):

decision_layer/encoders/openai.py → semantic_router/encoders/openai.py

 import os
 
-from decision_layer.encoders import BaseEncoder
+from semantic_router.encoders import BaseEncoder
 import openai
 from time import time
 

decision_layer/decision_layer.py → semantic_router/layer.py

-from decision_layer.encoders import BaseEncoder
-from decision_layer.schema import Decision
+from semantic_router.encoders import BaseEncoder, OpenAIEncoder, CohereEncoder
+from semantic_router.schema import Decision
 import numpy as np
 from numpy.linalg import norm
+
+
 class DecisionLayer:
     index = None
     categories = None
+    threshold = 0.82
 
     def __init__(self, encoder: BaseEncoder, decisions: list[Decision] = []):
         self.encoder = encoder
-        self.embeddings_classified = False
+        # decide on default threshold based on encoder
+        if isinstance(encoder, OpenAIEncoder):
+            self.threshold = 0.82
+        elif isinstance(encoder, CohereEncoder):
+            self.threshold = 0.3
+        else:
+            self.threshold = 0.82
         # if decisions list has been passed, we initialize index now
         if decisions:
             # initialize index now
             for decision in decisions:
                 self._add_decision(decision=decision)
 
-
-    def __call__(self, text: str, _method: str='raw', _threshold: float=0.5):
+    def __call__(self, text: str) -> str | None:
         results = self._query(text)
         top_class, top_class_scores  = self._semantic_classify(results)
-        # TODO: Once we determine a threshold methodlogy, we can use it here.
+        passed = self._pass_threshold(top_class_scores, self.threshold)
+        if passed:
+            return top_class
+        else:
+            return None
 
     def add(self, decision: Decision):
         self._add_decision(devision=decision)
@@ -41,12 +53,6 @@ class DecisionLayer:
             embed_arr = np.array(embeds)
             self.index = np.concatenate([self.index, embed_arr])
 
-    def _cosine_similarity(self, v1, v2):
-        """Compute the dot product between two embeddings using numpy functions."""
-        np_v1 = np.array(v1)
-        np_v2 = np.array(v2)
-        return np.dot(np_v1, np_v2) / (np.linalg.norm(np_v1) * np.linalg.norm(np_v2))
-
     def _query(self, text: str, top_k: int=5):
         """Given some text, encodes and searches the index vector space to
         retrieve the top_k most similar records.
@@ -64,10 +70,8 @@ class DecisionLayer:
         return [
             {"decision": d, "score": s.item()} for d, s in zip(decisions, scores)
         ]
-    
 
     def _semantic_classify(self, query_results: dict):
-
         scores_by_class = {}
         for result in query_results:
             score = result['score']
@@ -76,9 +80,12 @@ class DecisionLayer:
                 scores_by_class[decision].append(score)
             else:
                 scores_by_class[decision] = [score]
-
         # Calculate total score for each class
         total_scores = {decision: sum(scores) for decision, scores in scores_by_class.items()}
         top_class = max(total_scores, key=total_scores.get, default=None)
         # Return the top class and its associated scores
-        return top_class, scores_by_class.get(top_class, [])
+        return str(top_class), scores_by_class.get(top_class, [])
+    
+    def _pass_threshold(self, scores: list[float], threshold: float):
+        """Returns true if the threshold has been passed."""
+        return max(scores) > threshold

decision_layer/schema.py → semantic_router/schema.py

 from enum import Enum
 from pydantic import BaseModel
 from pydantic.dataclasses import dataclass
-from decision_layer.encoders import (
+from semantic_router.encoders import (
     BaseEncoder,
     HuggingFaceEncoder,
     OpenAIEncoder,

01_function_tests.ipynb → walkthrough.ipynb

 {
  "cells": [
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Decision Layer Walkthrough"
+    "# Semantic Router Walkthrough"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The decision layer library can be used as a super fast decision making layer on top of LLMs. That means that rather than waiting on a slow agent to decide what to do, we can use the magic of semantic vector space to make decisions. Cutting decision making time down from seconds to milliseconds."
+    "The Semantic Router library can be used as a super fast decision 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 decisions. Cutting decision making time down from seconds to milliseconds."
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Getting Started"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We start by installing the library:"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "[notice] A new release of pip is available: 23.1.2 -> 23.3.1\n",
-      "[notice] To update, run: python.exe -m pip install --upgrade pip\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "!pip install -qU \\\n",
-    "    decision-layer"
+    "!pip install -qU semantic-router==0.0.1"
    ]
   },
   {
-   "attachments": {},
    "cell_type": "markdown",
    "metadata": {},
    "source": [
@@ -54,11 +46,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from decision_layer.schema import Decision\n",
+    "from semantic_router.schema import Decision\n",
     "\n",
     "politics = Decision(\n",
     "    name=\"politics\",\n",
@@ -68,8 +60,7 @@
     "        \"don't you just love the president\"\n",
     "        \"don't you just hate the president\",\n",
     "        \"they're going to destroy this country!\",\n",
-    "        \"they will save the country!\",\n",
-    "        \"did you hear about the new goverment proposal regarding the ownership of cats and dogs\",\n",
+    "        \"they will save the country!\"\n",
     "    ]\n",
     ")"
    ]
@@ -83,7 +74,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -94,8 +85,7 @@
     "        \"how are things going?\",\n",
     "        \"lovely weather today\",\n",
     "        \"the weather is horrendous\",\n",
-    "        \"let's go to the chippy\",\n",
-    "        \"it's raining cats and dogs\",\n",
+    "        \"let's go to the chippy\"\n",
     "    ]\n",
     ")\n",
     "\n",
@@ -106,82 +96,51 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we initialize our embedding model (we will add support for Hugging Face):"
+    "Now we initialize our embedding model:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from decision_layer.encoders import OpenAIEncoder\n",
+    "from semantic_router.encoders import CohereEncoder\n",
+    "from getpass import getpass\n",
     "import os\n",
     "\n",
-    "encoder = OpenAIEncoder(name=\"text-embedding-ada-002\")"
+    "os.environ[\"COHERE_API_KEY\"] = getpass(\"Enter Cohere API Key: \")\n",
+    "encoder = CohereEncoder()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we define the `DecisionLayer`. When called, the decision layer will consume text (a query) and output the category (`Decision`) it belongs to — for now we can only `_query` and get the most similar `Decision` `utterances`."
+    "Now we define the `DecisionLayer`. When called, the decision layer will consume text (a query) and output the category (`Decision`) it belongs to — to initialize a `DecisionLayer` we need our `encoder` model and a list of `decisions`."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "from decision_layer import DecisionLayer\n",
+    "from semantic_router import DecisionLayer\n",
     "\n",
     "dl = DecisionLayer(encoder=encoder, decisions=decisions)"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 26,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'decision': 'politics', 'score': 0.22792677421560453},\n",
-       " {'decision': 'politics', 'score': 0.2315237823644528},\n",
-       " {'decision': 'politics', 'score': 0.2516642096551168},\n",
-       " {'decision': 'politics', 'score': 0.2531645714220874},\n",
-       " {'decision': 'politics', 'score': 0.2566108224655662}]"
-      ]
-     },
-     "execution_count": 26,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out = dl._query(\"don't you love politics?\")\n",
-    "out"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Using the most similar `Decision` `utterances` and their `cosine similarity scores`, use `simple_classify` to apply scoring a secondary scoring system which chooses the `decision` that the utterance belongs to."
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we use `apply_tan=True`, which means that a `tan` function is assigned to each score boosting the score of `decisions` whose datapoints had greater `cosine similarlity` and reducing the score of those which had lower `cosine similarity`. "
+    "Now we can test it:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -190,129 +149,56 @@
        "'politics'"
       ]
      },
-     "execution_count": 27,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "decision, scores_by_category = dl.simple_classify(query_results=out, apply_tan=True)\n",
-    "decision"
+    "dl(\"don't you love politics?\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "{'politics': 2.018519173992354}"
+       "'chitchat'"
       ]
      },
-     "execution_count": 28,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "scores_by_category"
+    "dl(\"how's the weather today?\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The correct category was chosen. Let's try again for a less clear-cut case:"
+    "Both are classified accurately, what if we send a query that is unrelated to our existing `Decision` objects?"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[{'decision': 'chitchat', 'score': 0.22320888353212376},\n",
-       " {'decision': 'politics', 'score': 0.22367029584935166},\n",
-       " {'decision': 'politics', 'score': 0.2274250403127478},\n",
-       " {'decision': 'politics', 'score': 0.23451692377042876},\n",
-       " {'decision': 'chitchat', 'score': 0.24924083653953585}]"
-      ]
-     },
-     "execution_count": 31,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "out = dl._query(\"i love cats and dogs!\")\n",
-    "out"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 32,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "'politics'"
-      ]
-     },
-     "execution_count": 32,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "decision, scores_by_category = dl.simple_classify(query_results=out, apply_tan=True)\n",
-    "decision"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 33,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "{'chitchat': 0.7785435459589187, 'politics': 1.1258003022715952}"
-      ]
-     },
-     "execution_count": 33,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "scores_by_category"
+    "dl(\"I'm interested in learning about llama 2\")"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 34,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array(['politics', 'politics', 'politics', 'politics', 'politics',\n",
-       "       'politics', 'chitchat', 'chitchat', 'chitchat', 'chitchat',\n",
-       "       'chitchat', 'chitchat'], dtype='<U8')"
-      ]
-     },
-     "execution_count": 34,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
    "source": [
-    "dl.categories"
+    "In this case, we return `None` because no matches were identified."
    ]
   }
  ],
@@ -332,9 +218,8 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
-  },
-  "orig_nbformat": 4
+   "version": "3.11.5"
+  }
  },
  "nbformat": 4,
  "nbformat_minor": 2