Corrected and elabborated on Notebook 02 introduction.

It was previously (incorrectly) stating that the dynamic route generates functions.

Corrected and elabborated on Notebook 02 introduction.
0bb4f975 · Siraj R Aizlewood · 9cef8cba · 0bb4f975
Unverified Commit 0bb4f975 authored 10 months ago by Siraj R Aizlewood
--- a/docs/02-dynamic-routes.ipynb
+++ b/docs/02-dynamic-routes.ipynb
@@ -26,7 +26,35 @@
      "source": [
        "In semantic-router there are two types of routes that can be chosen. Both routes belong to the `Route` object, the only difference between them is that _static_ routes return a `Route.name` when chosen, whereas _dynamic_ routes use an LLM call to produce parameter input values.\n",
        "\n",
-        "For example, a _static_ route will tell us if a query is talking about mathematics by returning the route name (which could be `\"math\"` for example). A _dynamic_ route can generate additional values, so it may decide a query is talking about maths, but it can also generate Python code that we can later execute to answer the user's query, this output may look like `\"math\", \"import math; output = math.sqrt(64)`.\n",
+        "For example, a _static_ route will tell us if a query is talking about mathematics by returning the route name (which could be `\"math\"` for example). A _dynamic_ route does the same thing, but it also extracts key information from the input utterance to be used in a function associated with that route. \n",
+        "\n",
+        "For example we could provide a dynamic route with associated utterances: \n",
+        "\n",
+        "```\n",
+        "\"what is x to the power of y?\"\n",
+        "\"what is 9 to the power of 4?\"\n",
+        "\"calculate the result of base x and exponent y\"\n",
+        "\"calculate the result of base 10 and exponent 3\"\n",
+        "\"return x to the power of y\"\n",
+        "```\n",
+        "\n",
+        "and we could also provide the route with a schema outlining key features of the function:\n",
+        "\n",
+        "```\n",
+        "def power(base: float, exponent: float) -> float:\n",
+        "    \"\"\"Raise base to the power of exponent.\n",
+        "\n",
+        "    Args:\n",
+        "        base (float): The base number.\n",
+        "        exponent (float): The exponent to which the base is raised.\n",
+        "\n",
+        "    Returns:\n",
+        "        float: The result of base raised to the power of exponent.\n",
+        "    \"\"\"\n",
+        "    return base ** exponent\n",
+        "```\n",
+        "\n",
+        "Then, if the users input utterance is \"What is 2 to the power of 3?\", the route will be triggered, as the input utterance is semantically similar to the route utterances. Furthermore, the route utilizes an LLM to identify that `base=2` and `expoenent=3`. These values are returned in such a way that they can be used in the above `power` function. That is, the dynamic router automates the process of calling relevant functions from natural language inputs. \n",
        "\n",
        "***⚠️ Note: We have a fully local version of dynamic routes available at [docs/05-local-execution.ipynb](https://github.com/aurelio-labs/semantic-router/blob/main/docs/05-local-execution.ipynb). The local 05 version tends to outperform the OpenAI version we demo in this notebook, so we'd recommend trying [05](https://github.com/aurelio-labs/semantic-router/blob/main/docs/05-local-execution.ipynb)!***"
      ]

 %% 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/02-dynamic-routes.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/02-dynamic-routes.ipynb)
 %% Cell type:markdown id: tags:
 # Dynamic Routes
 %% Cell type:markdown id: tags:
 In semantic-router there are two types of routes that can be chosen. Both routes belong to the `Route` object, the only difference between them is that _static_ routes return a `Route.name` when chosen, whereas _dynamic_ routes use an LLM call to produce parameter input values.
-For example, a _static_ route will tell us if a query is talking about mathematics by returning the route name (which could be `"math"` for example). A _dynamic_ route can generate additional values, so it may decide a query is talking about maths, but it can also generate Python code that we can later execute to answer the user's query, this output may look like `"math", "import math; output = math.sqrt(64)`.
+For example, a _static_ route will tell us if a query is talking about mathematics by returning the route name (which could be `"math"` for example). A _dynamic_ route does the same thing, but it also extracts key information from the input utterance to be used in a function associated with that route.
+For example we could provide a dynamic route with associated utterances:
+```
+"what is x to the power of y?"
+"what is 9 to the power of 4?"
+"calculate the result of base x and exponent y"
+"calculate the result of base 10 and exponent 3"
+"return x to the power of y"
+```
+and we could also provide the route with a schema outlining key features of the function:
+```
+def power(base: float, exponent: float) -> float:
+    """Raise base to the power of exponent.
+    Args:
+        base (float): The base number.
+        exponent (float): The exponent to which the base is raised.
+    Returns:
+        float: The result of base raised to the power of exponent.
+    """
+    return base ** exponent
+```
+Then, if the users input utterance is "What is 2 to the power of 3?", the route will be triggered, as the input utterance is semantically similar to the route utterances. Furthermore, the route utilizes an LLM to identify that `base=2` and `expoenent=3`. These values are returned in such a way that they can be used in the above `power` function. That is, the dynamic router automates the process of calling relevant functions from natural language inputs.
 ***⚠️ Note: We have a fully local version of dynamic routes available at [docs/05-local-execution.ipynb](https://github.com/aurelio-labs/semantic-router/blob/main/docs/05-local-execution.ipynb). The local 05 version tends to outperform the OpenAI version we demo in this notebook, so we'd recommend trying [05](https://github.com/aurelio-labs/semantic-router/blob/main/docs/05-local-execution.ipynb)!***
 %% Cell type:markdown id: tags:
 ## Installing the Library
 %% Cell type:code id: tags:
 ``` python
 !pip install -qU semantic-router==0.0.34
 !pip install tzdata
 ```
 %% Output
    [notice] A new release of pip is available: 23.1.2 -> 24.0
    [notice] To update, run: python.exe -m pip install --upgrade pip
    Requirement already satisfied: tzdata in c:\users\siraj\documents\personal\work\aurelio\virtual environments\semantic_router\lib\site-packages (2024.1)
    [notice] A new release of pip is available: 23.1.2 -> 24.0
    [notice] To update, run: python.exe -m pip install --upgrade pip
 %% Cell type:markdown id: tags:
 ## Initializing Routes and RouteLayer
 %% Cell type:markdown id: tags:
 Dynamic routes are treated in the same way as static routes, let's begin by initializing a `RouteLayer` consisting of static 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!",
    ],
 )
 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]
 ```
 %% Output
    c:\Users\Siraj\Documents\Personal\Work\Aurelio\Virtual Environments\semantic_router\Lib\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:
 We initialize our `RouteLayer` with our `encoder` and `routes`. We can use popular encoder APIs like `CohereEncoder` and `OpenAIEncoder`, or local alternatives like `FastEmbedEncoder`.
 %% Cell type:code id: tags:
 ``` python
 import os
 from getpass import getpass
 from semantic_router import RouteLayer
 from semantic_router.encoders import CohereEncoder, OpenAIEncoder
 # dashboard.cohere.ai
 # os.environ["COHERE_API_KEY"] = os.getenv("COHERE_API_KEY") or getpass(
 #     "Enter Cohere API Key: "
 # )
 # platform.openai.com
 os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY") or getpass(
    "Enter OpenAI API Key: "
 )
 # encoder = CohereEncoder()
 encoder = OpenAIEncoder()
 rl = RouteLayer(encoder=encoder, routes=routes)
 ```
 %% Output
    [32m2024-04-29 01:53:55 INFO semantic_router.utils.logger local[0m
 %% Cell type:markdown id: tags:
 We run the solely static routes layer:
 %% Cell type:code id: tags:
 ``` python
 rl("how's the weather today?")
 ```
 %% Output
    RouteChoice(name='chitchat', function_call=None, similarity_score=None)
 %% Cell type:markdown id: tags:
 ## Creating a Dynamic Route
 %% Cell type:markdown id: tags:
 As with static routes, we must create a dynamic route before adding it to our route layer. To make a route dynamic, we need to provide a `function_schema`. The function schema provides instructions on what a function is, so that an LLM can decide how to use it correctly.
 %% Cell type:code id: tags:
 ``` python
 from datetime import datetime
 from zoneinfo import ZoneInfo
 def get_time(timezone: str) -> str:
    """Finds the current time in a specific timezone.
    :param timezone: The timezone to find the current time in, should
        be a valid timezone from the IANA Time Zone Database like
        "America/New_York" or "Europe/London". Do NOT put the place
        name itself like "rome", or "new york", you must provide
        the IANA format.
    :type timezone: str
    :return: The current time in the specified timezone."""
    now = datetime.now(ZoneInfo(timezone))
    return now.strftime("%H:%M")
 ```
 %% Cell type:code id: tags:
 ``` python
 get_time("America/New_York")
 ```
 %% Output
    '17:53'
 %% Cell type:markdown id: tags:
 To get the function schema we can use the `get_schema` function from the `function_call` module.
 %% Cell type:code id: tags:
 ``` python
 from semantic_router.utils.function_call import get_schema
 schema = get_schema(get_time)
 schema
 ```
 %% Output
    {'name': 'get_time',
     'description': 'Finds the current time in a specific timezone.\n\n:param timezone: The timezone to find the current time in, should\n    be a valid timezone from the IANA Time Zone Database like\n    "America/New_York" or "Europe/London". Do NOT put the place\n    name itself like "rome", or "new york", you must provide\n    the IANA format.\n:type timezone: str\n:return: The current time in the specified timezone.',
     'signature': '(timezone: str) -> str',
     'output': "<class 'str'>"}
 %% Cell type:markdown id: tags:
 We use this to define our dynamic route:
 %% Cell type:code id: tags:
 ``` python
 time_route = Route(
    name="get_time",
    utterances=[
        "what is the time in new york city?",
        "what is the time in london?",
        "I live in Rome, what time is it?",
    ],
    function_schema=schema,
 )
 ```
 %% Cell type:code id: tags:
 ``` python
 time_route.llm
 ```
 %% Cell type:markdown id: tags:
 Add the new route to our `layer`:
 %% Cell type:code id: tags:
 ``` python
 rl.add(time_route)
 ```
 %% Output
    [32m2024-04-29 01:53:56 INFO semantic_router.utils.logger Adding `get_time` route[0m
 %% Cell type:code id: tags:
 ``` python
 time_route.llm
 ```
 %% Cell type:markdown id: tags:
 Now we can ask our layer a time related question to trigger our new dynamic route.
 %% Cell type:code id: tags:
 ``` python
 out = rl("what is the time in new york city?")
 get_time(**out.function_call)
 ```
 %% Output
    [33m2024-04-29 01:53:57 WARNING semantic_router.utils.logger No LLM provided for dynamic route, will use OpenAI LLM default. Ensure API key is set in OPENAI_API_KEY environment variable.[0m
    [32m2024-04-29 01:53:57 INFO semantic_router.utils.logger Extracting function input...[0m
    [32m2024-04-29 01:53:58 INFO semantic_router.utils.logger LLM output: {
    	"timezone": "America/New_York"
    }[0m
    [32m2024-04-29 01:53:58 INFO semantic_router.utils.logger Function inputs: {'timezone': 'America/New_York'}[0m
    '17:53'
 %% Cell type:code id: tags:
 ``` python
 time_route.llm
 ```
 %% Output
    OpenAILLM(name='gpt-3.5-turbo', client=<openai.OpenAI object at 0x0000024DD8AEAF10>, temperature=0.01, max_tokens=200)
 %% Cell type:markdown id: tags:
 Our dynamic route provides both the route itself _and_ the input parameters required to use the route.
 %% Cell type:markdown id: tags:
 ---