python-recipes/vector-search/02_hybrid_search.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Redis](https://redis.io/wp-content/uploads/2024/04/Logotype.svg?auto=webp&quality=85,75&width=120)\n",
    "# Implementing hybrid search with Redis\n",
    "\n",
    "Hybrid search is all about combining lexical search with semantic vector search to improve result relevancy. This notebook will cover 3 different hybrid search strategies with Redis:\n",
    "\n",
    "1. Linear combination of scores from lexical search (BM25) and vector search (Cosine Distance) with the aggregation API\n",
    "2. Client-Side Reciprocal Rank Fusion (RRF)\n",
    "3. Client-Side Reranking with a cross encoder model\n",
    "\n",
    ">Note: Additional work is planed within the Redis core and ecosystem to add more flexible hybrid search capabilities in the future.\n",
    "\n",
    "## Let's Begin!\n",
    "<a href=\"https://colab.research.google.com/github/redis-developer/redis-ai-resources/blob/main/python-recipes/vector-search/02_hybrid_search.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_SKIP\n",
    "%pip install -q \"redisvl>=0.3.5\" sentence-transformers pandas \"redis>=5.2.0\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data/Index Preparation\n",
    " \n",
    "In this section:\n",
    "\n",
    "1. We prepare the data necessary for our hybrid search implementations by loading a collection of movies. Each movie object contains the following attributes:\n",
    "    - `title`\n",
    "    - `rating`\n",
    "    - `description`\n",
    "    - `genre`\n",
    " \n",
    "2. We generate vector embeddings from the movie descriptions. This allows users to perform searches that not only rely on exact matches but also on semantic relevance, helping them find movies that align closely with their interests.\n",
    "\n",
    "3. After preparing the data, we populate a search index with these movie records, enabling efficient querying based on both lexical and vector-based search techniques."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running remotely or in collab? Run this cell to download the necessary dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_SKIP\n",
    "!git clone https://github.com/redis-developer/redis-ai-resources.git temp_repo\n",
    "!mv temp_repo/python-recipes/vector-search/resources .\n",
    "!rm -rf temp_repo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install Redis Stack\n",
    "\n",
    "Later in this tutorial, Redis will be used to store, index, and query vector\n",
    "embeddings and full text fields. **We need to have a Redis\n",
    "instance available.**\n",
    "\n",
    "#### Local Redis\n",
    "Use the shell script below to download, extract, and install [Redis Stack](https://redis.io/docs/getting-started/install-stack/) directly from the Redis package archive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NBVAL_SKIP\n",
    "%%sh\n",
    "curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg\n",
    "echo \"deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main\" | sudo tee /etc/apt/sources.list.d/redis.list\n",
    "sudo apt-get update  > /dev/null 2>&1\n",
    "sudo apt-get install redis-stack-server  > /dev/null 2>&1\n",
    "redis-stack-server --daemonize yes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Alternative Redis Access (Cloud, Docker, other)\n",
    "There are many ways to get the necessary redis-stack instance running\n",
    "1. On cloud, deploy a [FREE instance of Redis in the cloud](https://redis.com/try-free/). Or, if you have your\n",
    "own version of Redis Enterprise running, that works too!\n",
    "2. Per OS, [see the docs](https://redis.io/docs/latest/operate/oss_and_stack/install/install-stack/)\n",
    "3. With docker: `docker run -d --name redis-stack-server -p 6379:6379 redis/redis-stack-server:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define the Redis Connection URL\n",
    "\n",
    "By default this notebook connects to the local instance of Redis Stack. **If you have your own Redis Enterprise instance** - replace REDIS_PASSWORD, REDIS_HOST and REDIS_PORT values with your own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "# Replace values below with your own if using Redis Cloud instance\n",
    "REDIS_HOST = os.getenv(\"REDIS_HOST\", \"localhost\") # ex: \"redis-18374.c253.us-central1-1.gce.cloud.redislabs.com\"\n",
    "REDIS_PORT = os.getenv(\"REDIS_PORT\", \"6379\")      # ex: 18374\n",
    "REDIS_PASSWORD = os.getenv(\"REDIS_PASSWORD\", \"\")  # ex: \"1TNxTEdYRDgIDKM2gDfasupCADXXXX\"\n",
    "\n",
    "# If SSL is enabled on the endpoint, use rediss:// as the URL prefix\n",
    "REDIS_URL = f\"redis://:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create redis client, load data, generate embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from redis import Redis\n",
    "\n",
    "client = Redis.from_url(REDIS_URL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open(\"resources/movies.json\", 'r') as file:\n",
    "    movies = json.load(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from redisvl.utils.vectorize import HFTextVectorizer\n",
    "\n",
    "# load model for embedding our movie descriptions\n",
    "model = HFTextVectorizer('sentence-transformers/all-MiniLM-L6-v2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_data = [\n",
    "    {\n",
    "        **movie,\n",
    "        \"description_vector\": model.embed(movie[\"description\"], as_buffer=True, dtype=\"float32\")\n",
    "    } for movie in movies\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'title': 'Explosive Pursuit',\n",
       "  'genre': 'action',\n",
       "  'rating': 7,\n",
       "  'description': 'A daring cop chases a notorious criminal across the city in a high-stakes game of cat and mouse.',\n",
       "  'description_vector': b'\\x9bf|=\\x0e`\\n;\"\\x92\\xb7;<\\xcb~\\xbd\\xfad\\xce\\xbb\\xc3\\x16J=V\\xa7?=\\xedv\\x95<d\\xfa\\x06\\xbe\\x14Y\\xcf=(\\x07p=?\\xdb\\r\\xbd\\x95\\xf2H\\xbdje\\xc6<E\\xdfa=z8\\x16\\xbc\\x00\\xd4\\x13<>\\xaa\\x1c=\\xfd\\xee\\x89<\\xbd\\xb0-<\\x82\\xb2\\x9f\\xbc[\\x0b\\xc3\\xbd\\x98NR=xl\\xf7\\xbcN>\\x17\\xbe#\\x12\\x05\\xb99u\\xbf<\\xb0\\xe0b\\xba\\xd3\\xa6\\xa8\\xbdx\\xdc\\xec\\xbcRc%=\\xe4\\xe7r\\xbb\\x1eOG=?(\\x85=o@\\xa2\\xbc2Z\\xd0\\xbdC%K\\xbd\\xb9\\xed\\x94\\xbcR\\xddH=\\x92&F<\\xc6*\\xec<\\x90\\xd8\\x8d\\xbd\\xcbZ\\x98<\\t\\xa3\\xa3=>g3\\xbd&\\xcd\\xbd\\xbd\\x95$\\xf7;\\xfd\\xf4z=\\xfc\\xb4\\x8c=\\x85\\x0e\\xc6\\xbdnI\\x90\\xbdJ\\x16\\xbd;s\\xe7\\x0c\\xbd 3\\xc9\\xbc\\x85\\xf8\\xbb\\xbc\\xbf&u\\xbb5\\x8f\\xca<\\x05\\x80J=\\x0f\\xaf*=\\x8bOU\\xbd\\xc8\\xf0\\x95\\xbc\\x1d\\x02\\x19=)\\xf4K<\\xcb\\xc2\\t=F\\x83\\xac=\\x9f\\xd7\\xb8\\xbd\\xf2\\xb5\\x9c\\xbdB\\x85\\x18=\\x96d&=-3\\xf8<\\xfa\\xf7\\x88<\\x16v\\xf2\\xbb-=[\\xbd\\xf7\\xac\\xee\\xbb5:A\\xbd\\xd9d\\x19\\xbdrd\\xf2\\xbb!\\xbax;\\xdc;O<\\xb61,\\xbc\\xed\\xae\\xae=^\\x00-\\xbc\\x1a\\x06\\xae\\xbda\\xd6\\x1a=\\xcc\\xbf\\xcd=\\x1f\\x150=\\xcf\\xf1\\x9d\\xbc\\xa9GK=\\xaa\\xb8 =\\xb4\\xf1I\\xbd\"e\\x9e\\xbbF\\x8b\\xf7:\\x94\\xf8\\x1c=\\xa9\\xba\\xde<\\xcco\\x16\\xbb\\xe6]p\\xbb\\xbb\\xd5<<\\xac\\x95\\xa3\\xb8\\xc29s<&4&<o\\x1c\\x18<\\x18\\xd9-\\xbd\\xe1\\xe6\\x98<\\x11\\xa1N=\\xa1/\\xa5=/\\xf3\\xdd<\\x0eL\\x13<n\\x0f\\xce\\xbaT\\x9e\\xdc\\xbc\\x9a8\\x05=\\x11\\xa1\\xf5<h\\xd8R\\xbc1\\x94-\\xbc\\x1d\\xd8\\\\9\\xa41\\xec=W\\xf5V=8G\\xd6\\xbc\\xa2\"S=\\xc8\\xd9^\\xbd\\xab\\xa3\\x91<\\xdf\\xd9\\x13<\\x95\\xb2y\\xbb\\x85\\x8d/\\xbd\\xda\\x06p<-\\x95\\x88\\xbb\\xa2\\xd0\\x9d<J\\x02\\xb6=\\x18\\xf1\\xad\\x89+\\xf2\\xa6\\xbb\\xc5\\xfbe\\xbd\\x7fQK\\xbb>\\x10\\x90\\xbbvt\\xb9\\xbb\\x00\\xc9\\xb9\\xbb\\xfehk=\\x9a\\r\\xad<3f\\xa8\\xbd\\xbd]\\xcc=\\x15\\xe0 \\xbe\\xc74/\\xbd{f\\xf7\\xbcQ\\x9av=\\x11\\x0cq<,\\xda\\x1c\\xbd\\x01\\t\\x8b<\\xf0n\\xa6\\xbc\\xe4t\\x86<\\x82\\x87\\x19=v\\xae\\xe4\\xbc4m^\\xbc\\nV\\x0e\\xbd\\x81\\xb0\\xe3\\xbc\\xd3FU;\\xaaG|\\xbdW\\xfb\\x8b\\xbd\\x7f\\x81*\\xbdy\\x83\\xf4={\\xb7\\x10;\\x15!\\x0e\\xbd\\xfa\\xd3\\xb4=\\x15&\\x15\\xbdM\\x86\\x83=m$:</\\xea\\xa1<\\x1f\\x08\\x8d\\xbd\\xa0\\x00i\\xbd5\\x01\\xdd<\\x06\\x87\\xd6=4\\x98\\x9c\\xbdZ|!\\xbd:\\x1c\\xc5\\xb9\\xbe\\xb3\\x93\\xbc\\xf6\\xcb>\\xbdv\\x1bF\\xbd\\xa2?\\x14\\xbe\\xc5\\x8f(\\xbd\\xe3O\\x89\\xbd\\x17\\xae\\xd4<\\xa3\\x12\\xc3=\\xaf\\x05O\\xbd\\x7f\\x8ep\\xbc!\\xb5\\xac\\xbc\\xc4\\x9ee\\xbd9\\x8es;[a\\xc1;\\xd2\\xfaB\\xbd\\xf9#\\xfe:\\x90\\xe6\\xf4=\\xb2\\x15*<~\\xf8\\x1b=\\x01\\xfcV\\xbd\\xcf\\xd1\\r=*\\xee\\x06=\\x18u\\xba\\xbd\\x02\\xa4\\xd6<\\xf8\\xeb\\xd9;\\xc49/=\\xa8\\xc2\\x85=u\\x0b\"=\\xe9i\\xef<4\\xe8c=\\xfa2\\x08\\xbe\\xd4\\x12;=,VW;\\x15\\xa4b<\\xb0\\x9d\\xb7<\\x95r;\\xbd{z\\x91\\xbcI\\x00<\\xbd\\x18\\x1a\\xa3<\\xf9J%\\xbc\\n\\xe7\\xbf\\xbbr\\x87\\x12=\\x97\\x1d\\x95=\\x83|\\xfd\\xbc\\xed\\xf1\\xd1\\xbd%z\\x84;\\xcb\\tu=c\\x8ai<A\\x91R\\xbd\\xd6\\xf3m\\xbd\\x8e\\xb83=R\\xedF=$\\xf3\\xd1\\x08pA\\xba<#\\xacO\\xbdK\\x0f\\xc7;\\x85\\xf4\\x04\\xbdM\\x82\\x92\\xbd\\xa9\\xddD=h\\xd8;\\xbc\\xed;\\xf4\\xbc\\xba\\x8f\\x97\\xbd8\\\\\\r\\xbd\\xec\\x8c\\xf5\\xbd\\x99\\x13(=\\xa0\\xc8\\xc6=\\xb1\\xed\\x1a=\\x95\\xa8\\xf8=\\x96\\xc1\\xee\\xbcu-\\x18\\xbb\\xf0~;<\\xd0F\\t\\xbd\\x0c\\x08\\x17=\\x94\\xa5\\x1e=\\x12K\\xcb\\xbd0\\xf7\\x8c\\xbd)b\\xed\\xbb\\xa9[\\x19\\xbcK\\x0c\\x13\\xbcgq\\x83=\\xf2wd\\xbd\\x8c\\xc7\\xd1\\xbb<lY\\xbc\\xa3|a=G\\xcf\\xfd\\xbc\\xf7\\xa4\\x83\\xbb\\x9dO\\x19\\xbd2\\x02]\\xbd\\xbe\\xeaz=\\xff5\\x9c=8^\\xa9\\xbdM^9\\xbc\\x95\\xe4N\\xbc\\x7f\\x07x\\xbd\\x18{\\xa0=<\\x9f\\x96<\\xf9s8\\xba\\x9f\\xbb=\\xbd\\xcb|(<x\\xdf\\xb4\\xbbi\\xc9\\x0b\\xbd\\xc4\\x01\\x95\\xbd\\xfc\\xc6T=\\x1fp\\xd1<p3\\'\\xbd\\xa5\\x00H<\\x80\\x0f\\xb8<-U}\\xbd\\x81}\\x01=\\x03\\xca[\\xbd#\\xed\\x03<\\xfcb\\x0f\\xbd\\xda\\x8e\\xe7\\xbc\\xdb\\x16\\xc8<\\xbd\\x08\\x9c=\\xff\\xd4\\xa6\\xbdKQ\\xe5=g-O<\\xe6\\xf22=\\xd126\\xbd\\x02\\xe3\\xf2\\xbc\\x14[\\xa7<w\\xb2\\x02\\xbe\\xfan2\\xbd\\xab\\x80\\x8a=\\x13\\xc4\\t\\xbd\\x17\\xb8\\xcd\\xbc7\\xdb\\xad\\xbb\\x8b\\xfd\\xde\\xbc\\x10\\x17E=y\\x06\\xbd=\\x18&m=\\x19X\\x8e=\\xe2\\xae\\xa4=n\\xa3\\xca\\xbbz?\\r\\xbc\\xd39\\x9c<Hl\\x8e\\xbd4\\x10k=\\xeb\\xff\\xbe;\\x80\\x16\\xff<o8\\x92<_2\\x8c;P\\xac\\xa3=\\x00,v<\\x99\\x89\\xf0\\xbb\\xae\\xdb\\x07\\xbc\\x8b\\xae\\xbd\\xbc\\xb6\\x8f\\xb4\\xb2\\xad\\x88\\xd3\\xbd\\x88\\xe9j=\\xe7\\xdb\\xa7\\xbd\\xde\\x16\\xe5<<\\x19p=\\xf3\\xe6\\x9f=\\xdbGh\\xbd\\xe7\\x9a\\xf4\\xbd[\\xd6\\x07\\xbc8\\xddj<+tw=\\x8d\\xd0\\xe1<\\xc5\\xae\\x1e=\\xe3F\\xc4<\\xb50\\n<\\x1djd\\xbc\\xba\\xfa\\x8c=\\xc7\\x8a\\xa6\\xbc\\x19.\\xcd\\xba\\xafp\\xcf=\\x1fT-\\xbd\\xccQn=:\\x16\\x9f\\xbd\\x86\\x8a_=<\\x13#<G\\xaam;)\\x86\\x00\\xbe\\xdcy\\x8b\\xbcfUG=\\x9f\\xa3\\xca=\\xae\\xbdq\\xbc\\x98\\xe3:\\xbd\\x9a\\x93]<\\x86]\\xd1;\\xc8d\\xae=\\xa7\\x1f\\x03\\xbd\\x02L\\x89=a:s\\xbd\\xa3\\x1eb=\\x1b\\xc9\\t\\xbb\\x9a\\xfb\\xe7<r\\xce\\xe4\\xbcTV#=t\\x8bk\\xbd\\xd8h\\x01<\\xf1\\xe5N\\xbdH\\x0c\\xb1\\xbcl\\x01J\\xbdg\\xf4~=J\\xe3Z\\xbd\\x91/\\xf1\\xbbD98=\\xb92T\\xbc\\x1b\\'\\x81<\\xc8\\xa0M=\\xb8\\xde\\x05<\\x1aI|\\xbd\\xcb\\x98w<\\xdd\\xd3\\xa7\\xbd\\xdaS \\xbdp\\x13\\x07=\\x13&\\x14\\xbc\\xc7v\\xe9<\\xfb,\\x97='},\n",
       " {'title': 'Skyfall',\n",
       "  'genre': 'action',\n",
       "  'rating': 8,\n",
       "  'description': 'James Bond returns to track down a dangerous new enemy who threatens global security.',\n",
       "  'description_vector': b'\\xa0D\\x9e\\xbdB\\x9b\\x89\\xbc\\xd4\\x16\\x95\\xbc\\x82\\x0fT\\xbc\\xac/g=Y\\x8d\\x13\\xbc\\x9d\\x84$=k\\x07/\\xbc\\xb6\\xa64<\\xb9\\xf3\\xc1<\\xc5\\xd4\\xba;\\xe5\\xc2\\xcb<\\x1fC3\\xbd}\\x82\\x92=EG\\x96\\xbd0\\xe8\\x1b\\xbd9\\xed\\x8c=\\xce\\xe5\\x1b=\\xbd\\x86\\x05<A\\xc0\\xe6<\\xe4Q2=\\xf70\\xb5<\\x93\\xd7\\xb6<\\xc8\\x08\\xdd\\xbc\\xc7\\x07\\xc5\\xbd\\x90;\\x12=\\xb2\\xab`=\\x0b\\xf3?\\xbd\\xd5\\xbe\\xb0\\xbd\\xb1\\x14\\xa2\\xbb\\x06\\xda\\x12=\\xf9\\x0b-\\xbd\\xcc\\x03\\xe5;!\\xa2\\x9e<*\\xd2\\x0b=y*h;\\xe6\\x80\\xf7<\\xc0\\x00\\x19\\xbd\\xc1\\x94\\x85=\\xa2y%\\xbd#px\\xbd\\xc7I:=\\xf7\\x8d\\xe8<[J\\xc1=\\xe5\\xa6\\x08=\\xb4\\xbf7\\xbd\\x15\\xbeE\\xbd|?V\\xbc\\xf5\\xabk=<,\\xa1\\xbd(\\xb9\\x98=6\\xd5Y\\xbb\\x12@\\x00\\xbdX>\\x85<\\xa29,=\\xbb\\xf5\\xdf\\xba\\xa0\\x14:\\xbdL9\\x08\\xbd\\x02\\x0c\\xbe\\xbcr\\xb9\\x9a<\\xab_6=\\x17Ub\\xbd\\xa4\\xb7#=[\\xee\\xa2\\xbag\\x95\\xe1\\xbc\\xfc\\xefX=\\xa2u\\x11=>\\xd86=\\xb8\\x06\\x9f\\xbc(\\xe5\\xf0<#\\x15t=\\xa0\\xaf\\xd0\\xbbeK-=\\xd5H\\x11\\xbd\\xd2\\x036=\\xff\\x15\\xd8<0x\\xfd\\xbcO\\x10\\x9b=\\xb8\\xdf_\\xbc\\xbe\\xff\\x03\\xbd\\xfbD\\xaa=\\xc5\\xab\\x0b\\xbd!$\\xe6\\xbc7\\x0cr=v\\xbc\\x99=\\xb6\\xae\\xa6<\\x1e\\x9b$\\xbd\\x98y\\x06\\xbd\\xe2\\xcf\\xde=\\xefX\\x8f=g%\\r\\xbd\\xbby\\x0e\\xbc4\\xe0\\t<\\'\\tI=\\xf8w\\x10\\xbd\\xfc\\xd4;\\xbd\\x82\\x0f\\xd9<\\xcd\\xe8\\x93\\xbb\\\\\\xdf\\xba\\xbd\\\\ c=|\\x9b\\x97;\\x19u\\xe0\\xbc\\x9a\\x10\\x9e\\xbdr\\xf4~=e\\x9eh<s\\x070;\"\\x9br=\\xe8C\\xe8:N\\xd8\\xa6\\xbb\\xb7a2\\xbdh\\xccg\\xbb\\xf6\\xe9\\x00=\\x92\\xc4\\x85;\\xf4\\xf7g\\xbd\\x15\\xb2\\xdc=N\\xca\\x83\\xbd\\xcbR\\x8b\\xbc\\x97F2=\\x0b\\xe4\\x9b\\xbd\\x1d\\xbb\\x91=\\xb2=^<\\xc6\\x92\\x06=4@\\x90\\xbd\\xda<\\xf5;\\x94\\xc6\\xdc\\xbcI\\xd8\\x19=(b\\x0b\\xbd\\xaeb\\xfa\\x88jx\\xef\\xbbz\\xe0\\xc6;g\\x08~=\\xd7/&\\xbd[\\x87\\x93\\xbd\\x93(\\xe7\\xbc\\xb8&\\x08\\xbd\\xe4\\x86\\xb1=,\\xd8p\\xbcl\\xb4\\xa2<\\xbc\\xdd|\\xbd\\xd6\\xe5\\x83\\xbc\\xf2\\x94\\x94<<\\x0c\\x81=Hd\\t\\xbcb\\r\\xab;\\x1c\\xe8T=\\xef\\x83\\xd8=\\xa1\\x97\\xad=\\xd1b[\\xbc\\xa5\\x96\\xfc\\xbdge\\xf1;\\xc4\\x8e==}\\xee\\xa2\\xbc!\\xb8\\x0e=\\xe3\\x12X=\\x1d\\xa7R<>h\\xa6<D\\xb1)=\\x9eW\\xd0<\\xd7\\xe1\\x83\\xbd\\x85p\\xfb;\\xe5F\\xa0:\\x05\\xda\\x9f\\xbb\\xb0u\\xc0\\xbb\\xee\\xb2\\x82=`9\\x94\\xbd\\xbf1\\xd8\\xbb\\x83\\xe6\\x93\\xbc\\xb5\\xb1\\x14\\xbdq\\x1f/<\\xbc?k=\\xee0\\xe2\\xbd\\xaa\\x8c\\x0f\\xb9g\\xfe\\x80<\\xd9\\xa3\\xca\\xbdv>\\xaf<\\xc4\\x8b\\x83\\xbb\\x19\\x1e\\x17\\xbd\\x87L*\\xbds\\x08m\\xbc\\xfcV\\x989C\\xf9\\xc2\\xbd\\x00g\\x11=\\xcf\\xdc\\xd7\\xbd\\xc9\\xfax<\\xa2\\xc0\\xa9;t\\xd6\\xc8\\xbb@1I\\xbd\\x19\\x7f\\x0c\\xbd\\x87P\\xb8\\xba\\x0e\\x14\\xf1\\xbc\\x9f\\xf2\\xca\\xbd\\xf5uA\\xbc\\xb6\\xf9<;\\x1e\\x0e\\x9d\\xbb{\\xd1r\\xbd\\xd4\\xc3}\\xbc\\xc6\\xc0\\xe5\\xbd\\x05\\x18\\xf4=\\xaaTp\\xbd!gC<\\xe5:\\x16\\xbd1|\\x19\\xbb\\xe3.\\xbf<\\xea$5=QGl=1\\xbd\\\\=bGE\\xbc\\xae\\xb8\\x85\\xbd\\xd2\\xd8Y\\xbd\\x17\\xfb\\xff;0\\r\\x88=\\x8f\\xe1\\xab=\\x84{@\\xbd\\x11O\\xc6\\xbb\\xba$o=\\x0e#\\xf4\\xbdk\\x98\\xde=\\x96~0>\\x82 \\x98\\xbc|\\xd9\\x03\\xbe\\xaek\\x8a\\xbd\\xa1l/=\\xd1ul\\xbd$\\xfb\\xd5\\x07\\xcb\\xe9\\xcd\\xbc\\xf1\\x17>\\xbdO\\xc0\\x83\\xbc=\\x1bY\\xbd>\\xd8\\x94\\xbd\\xc0/\\x1d\\xbc4M\\x07\\xbeN\\xdd\\x8f=+\\x08\\xc1\\xbcV\\xe6N<n\\x9dk\\xbd\\xb9\\xd9\\x19<\\xed\\x80\\xc3=[\\xe7\\xea<\\xef\\r0<\\x9d\\x02 =\\x1b\\x1a\\xda\\xbc\\xc6\\xcc\\xe0<\\xbd{\\xa0=\\r\\x01|;\\x07\\xd7\\xc2=\\x9f\\x88\\x89\\xbd-\\x0e\\xa4<~\\xa9\\x95\\xbc\\x02L\\x90;\\x9f2\\x98=\\x14\\xc4\\x86<\\xd7\\x0bs=\\xb6,\\xff\\xbb\\x90\\xa8\\xa9\\xbc\\xc3\\xf8\\x95\\xbc\\xcd\\x9bc\\xbd\\x0b\\xad\\xee;*\\xb2\\xf5<1f|\\xbd\\xbb\\x98\\x0c>J\\x8f\\x7f<\\xccE\\xb5\\xbd\\x1aF\\x05=a@/=\\xa0\\xad1\\xbd \\xb1\\x8a=\\x14u\\x04\\xbc\\x9cI \\xbd9\\x8b\\x9b\\xbd\\x8bF\\xc4<y\\x0b\\xae<\\xe7\\x9eA>=\\xf7\\xf7;K\\xa6\\x05\\xbd\\x9du\\xe8<\\xb4\\x88N=\\xab\\x13\\x07\\xbd\\xef_`\\xbdS\\xc7\\x99\\xbd\\xd7\\x92\\xb9<Ok9\\xbd6\\x0e\\x9f\\xbc\\xf3\\x80\\xbb<L\\xaa\\x9e<\\xba\\x88Q;L\\xddJ\\xbc_\\'%\\xbd\\xa8\\x93\\x84=\\x01\\x86\\x07\\xbc\\xd0\\x12^\\xbd\\xa5\\x94\\xa2\\xbc\\x04\\x02\\x95=\\xcf\\x16\\xa4<\\xc6<\\xf0\\xbcX\\xd8\\x83\\xbb\\x9cX?<BPm\\xbc.\\xb2\\x96\\xbb\\xef\\xba\\xc3<l\\xcb\"\\xbd=\\xf2\\xd1\\xbd\\x06M\\x14\\xbe\\xaa+\\x91\\xbd\\xe1\\xd7Y=\\x92\\x016=i\\x97\\xb4\\xbc\\x0c\\xf4\\xf0:\\xc8\\xb3c\\xbc\\xb3z\\x1f=\\xa7i\\x18=\\x08\\xacN=K\\x8a\\x1b=\\xf2\\xb2\\xa7\\xbc\\xffT\\xe0\\xbb\\x05\\xc2\\x97\\xbc_Q\\x8b;s\\x1f\\xbd\\xbd+b\\x8c=h\\xd7\\xbc<za\\xab\\xb2@eF\\xbd\\xeb\\xf2\\r=;\\xecN=\\x92\\xff\\x9d\\xba\\x9b\\xbc\\x82\\xbb\\x152\\xf3;s\\x8a&\\xbd\\x8e[\\xd4\\xbc1X\\x19<\\xc5]\\xdc\\xbd9\\x9a\\'=\\xc3\\nR\\xbdYd\\x05\\xbc\\xeb\\xa8\\x8b:j\\x00\\x03\\xbd\\x17Lc<\\xa83\\xd0;\\xdd~\\x05\\xbe\\xab\\xd8\\x08\\xbdH\\x9d\\xf0;\\xd3\\x81\\x13\\xbc\\xcc&:<\\xd3\\xcf\\xf9<\\n0\\xdb\\xbc\\xf6\\xd7\\x84=\\x19~C\\xbdG\\x18\\xf6;\\xf8G4=\\xb6\\x11\\x81<\\xb32\\xed=\\xccZ9=\\xb7\\xb5I\\xba\\x8eD1=m\\xc3\\x02=\\x8c~\\x81\\xbc\\xf5\\xe1m=\\x05\\x8a\\xee\\xbc^\\xe0\\x07<\\x08\\xcd\\xc0=\\xa3P\\xb5=\\x1a\\xe3\\x1a\\xbd@\\x17|=i\\xf5\\x82\\xbd^\\xae\\x91=\\x11\\xfcB\\xbd\\xf0\\x85z\\xbd]\\xb6L=\\x8a8\\xf7\\xba>\\xd8)=\\x12G\\xe1\\xbd\\xden\\x18<\\xabem\\xbd\\xc4\\x9a8\\xbdh\\nL=`\\xbd8=U\\xe1\\xe1<\\x01\\xa0-\\xbb\\xa2v\\xab<\\xfeD(\\xbc\\xc0\\xfcy<\\x11y\\x96\\xbd\\xa8\\t\\xbf\\xbdIu\\xf8:\\x9a\\x1b:='},\n",
       " {'title': 'Fast & Furious 9',\n",
       "  'genre': 'action',\n",
       "  'rating': 6,\n",
       "  'description': 'Dom and his crew face off against a high-tech enemy with advanced weapons and technology.',\n",
       "  'description_vector': b'&\\xa5\\xc7\\xbc\\xf7,\\xa2==\\x19H\\xbcF\\xc6t\\xbd\\xa3\\xa2C=\\x15\\x0f\\x18\\xbc\\xc8Kz=\\xeb\\x13\\xa0=\\xe5\\xe1\\x8c\\xbd\\xc3\\x84&=wZ\\x07=\\xbf\\xa8M\\xbc\\xb0\\xfaq=d\\x8b\\xe3\\xbc\\xdb\\xa3A\\xbd)\\'\\x13\\xbd\\x00\\x84\\x8a=\\xfb\\x9e\\xdd;@&s=\\x9b0l<\\xcbS\\x03\\xbcQ\\xf1:\\xbc\\xe6\\x07\\x14=u\\r\\x03\\xbd\\xa8\\x18\\xb6\\xbd\\xc5\\xf0\\xbf=b(\\xae=4t\\x91\\xbd\\xfc\\x96n\\xbc\\xc8>\\xbb\\xbc\\xb6\\x87\\t=\\x7f\\xc0\\xda\\xbc\\x8d\\xf6@\\xbcf\\xcd\\'\\xbci\\x9a\\x10\\xbe\\x00\\x98\\xaf=\\x9c\\x8f\\xd1\\xbc$\\xa4C=$\\xee)\\xbc\\x80g\\x9d\\xbcm6\\x98\\xbd\\x00\\x01\\x8a\\xbd\\xc9l\\x15<pm\\x15;\\x8f\\x97 =\\xc4\\r\\x98\\xbd\\x9cL\\x89\\xbc\\t;\\xc3\\xbdC\\xaf\\x9b=\\x8c\\x04\\xd0\\xbb\\xddS\\x03\\xbdb\\x99\\xbe\\xbd\\x97\\x02[=y/D\\xbc\\xb1\\xab>=2\\x19\\x03\\xbd\\xf1\\xba\\xd5<\\x0b\\x8b\\xa2\\xbc\\x80K\\x8a=\\xf7\\'h<\\x89\\xe2\\n\\xbdX\\xd4\\xcd<\\x03?9\\xbcZ\\x1eh=\\xcc\\xa8a=\\xc7\\xcd\\xbf\\xbb)\\x00;=jK\\x9e=\\x95\\x84\\x97\\xbdv\\x82\\xb3=\\xa1\\xd8\\xb8;\\xd3\\xa6j<\\x87\\xdd\\x9b\\xbc3\\x03}\\xbd\\xbc\\xa3\\xdc<n-\\xd8<\\xc7\\xa9\\xf6;\"\\x1e\\xfc\\xba+\\x83\\xf5=+n;\\xbd\\xf3\\xd3G=\\x98L\\x10\\xbdL\\\\\\xe6\\xbd\\xfd\\x9e|\\xbczZ\\xb9\\xba\\x8a\\xceo=x\\x0f\\x19\\xbd\\xf5\\xcd%\\xbd\\xe9\\xd5+=.P\\xce<\\xc2:\\xa0\\xbdV\\xb9\\x85;\\x08&\\xa2=\\xc1\\xb6\\x96=\\x89r\\xa4<\\xadqg=\\xde\\x0f1=1\\x8b\\xe0<\\x92\\xaev\\xbd\\xeb\\x12\\x19=\\x83\"\\x9f=O\\x8e\\x8c<\\x11&\\xe6\\xbd\\x00\\xb9\\x91\\xbc<\\xe8,\\xbc:\\x87\\xb7\\xbc8PF=\\xcd\\xe11<|<\\xf4\\xbb(\\\\\\x8b\\xbd\\xfa\\x03\\xb2<jG\\xf3\\xbc}\\r\\xa7\\xbd\\xd7\\x98w\\xbd ,\\x81\\xbc\\xeb\\xaaV\\xbc\\x1e\\xf2\\x10\\xba\\x96\\x9d&=\\xe0\\xb0\\x8a\\xbdy\\x1b\\xa6\\xbdF\\xc2\\x17=\\xa4\\x88\\x89\\xbb\\x91p?\\xbcoo\\x1a\\xbd\\xa7\\x7f\\xcf=M\\x97\\x85\\xbd\\xff5X=\\x05\\xbau\\x89k\\x95?;\\t\\xfdX<\\xb9+6\\xbds:k=\\xda\\xbe\\x16=\\x0c\\xb7\\xb1\\xbc\\x9f2%\\xbd\\x02\\xc6\\x1b<\\xddP\\x0c\\xbd{\\x04\\xb3=\\xa0$\\xa3\\xbd\\x9a\\x082\\xbd\\xc4\\xe48\\xbdH\\xa1\\x9b<\\xe0\\x1b\\xa8;\\x90B\\x92;q\\x18\\x1e\\xbd\\x81\\xc2]=y\\xc1{\\xbc\\xe2\\x1b\\xc1:\\xae\\xa4\\xc9\\xbcRl\\xf9<\\xa4K\\x97\\xbc\\xb1\\xa6s<\\x1d\\xa7\\xa8<\\xcf\\'\\x97=\\x8a\\xef\\xb5\\xbd\\x16\\x81\\r\\xbd\\xcf\\xad\\x82\\xbcQ\\x9d\\xe6;\\xd2\\x1b\\xe5\\xbd\\xbeq\\xb9=\\xc7\\xfe\\x9f:l\\xd3\\x9b=\\x93\\xfb\\xc1\\xba\\xea\\xc2\\\\=9\\x188\\xbd\\xd7\\x1b\\xc6\\xbdVt\\xdf\\xbcaA\\xb9=\\xb6P6\\xbd\\xa0\\x9f\\x19=\\xf8\\x93\\xb9\\xbc=\\xfax\\xbd\\x9c!\\xd1\\xbc\\xd5@\\r\\xbd\\xbc\\xee1:\\xda)\\x89\\xbd\\xbd\\x9d\\x9c<\\xf7d\\xe2<?zZ<I\\xb5v=\\x90-\\xa3<\\xf3V\\x19\\xbd\\xa9\\xc5z<[u\\xff<\\xf3A\\xfa<\\xc7\"\\xfa<\\x161\\x1c\\xba3\\xfd\\xb6=\\xc2/\\xbc\\xbc\\xe3\\xc1\\x18=\\xbf}]=H3\\x85=w\\xe7\\xff\\xbc\\xfcJe\\xbdQ`\\xd9\\xbc\\xca/\\xde\\xbc\\x0fP+\\xbd\"\\x8b.=\\x98\\xc5S\\xbd\\xbbC\\x0e\\xbdbN =\\x9dB\\xb6\\xbd\\xaa\\xffH=\\xca\\x94\\n=\\xb8e\\x1d\\xbd|\\x8a\\xb4<\\x81\\xf5-\\xbd\\xcc5\\xa4\\xbb@]t\\xbd\\xf9\\x82d<Y\\xf9\\x9b<\\xc5\\\\\\x83<\\r\\x84\\xda9\\x8f6\\xec<\"*(\\xbd\\xee\\x85|\\xbd\\x90c\\xe8\\xbc\\x82*;=\\xd3\\xd9\\x07\\xbdGA\\xa3\\xbd\\xd9\\x87\\x88:\\x02ql\\xbc\\xa7\\xb9\\xfb\\xbc\\x94\\x13\\xb4\\x08\\xb9\\x04\\x87\\xbdL1\\xcc<\\x84\\x92\\x10<Q\\x01\\xdc\\xbb;\\x93N=\\x01!V\\xbd\\xfe@\\xef;\\x06|e=g\\xeb\\xb4\\xbc\\xf9\\x97\\x8b=\\xba\"?=H1(\\xbc\\x82\\xfcm\\xbdz\\x9ef\\xbc\\xc88\\x8e=\\x15y\\xc1\\xbc]<\\x82=\\x99k\\n\\xbd_$\\x9e;\\xe0f\\x12=Q\\x068>\\xe1\\xd1Q\\xbdU\\x15\\xcf\\xbc\\x13\\x0c\\xb0\\xbc3\\xc8\\xfc<\\x04\\x8d\\x98=t\\x0e9=O3K=K\\xf2\\xcd\\xbc\\xdf\\x04E\\xbd\\xfc\\x987;\\x9e\\x9ct\\xbd\\xbfy|=\\xf8\\xd2\\x80<\\x00\\xa4\\x0c<\\x01\\x0e\\x18>\\x11\\x14q\\xbdi\\xe6Q=qR:\\xbd\\xbf\\xd4k\\xbd\\xbdX\\x81=\\x00|\\x98\\xbc\\n\\xbe\\xaf\\xbd\\xc6\\xe4\\xc6=\\xf4\\xc7\\x8e\\xbd_\\xd9\\xff\\xbc\\xc6\\xe50\\xbd_-\\xaa\\xbc\\x16\\xdf\\x92;p\\x9e\\xc2<yn\\xb6\\xbc\\xba\\xcb\\x8f\\xb9\\xf4\\xfd<=D8\\xb6\\xbc\\x94\\xfb\\xc3\\xbdR\\xe6v\\xbc\\n\\xa5Q\\xbcSm\\x8c=\\r\\xed\\x88=+e#<KYG=\\x90\\xdd\\xa0;\\xa9\\xfe\\x01=WC\\xa9=k\\x15\\x1f\\xbd\\x81\\\\\\x83=\\x96\\xee\\xe5\\xbcc\\xd8\\xd5=\\x98\\xbe\\x99\\xbd\\xb9\\xfe6\\xbb\\xadzZ=Ei\\xf7\\xba\\xef\\x1b\\r\\xbd\\x15\\x00\\xdc\\xbb\\xd6X-=\\n\\xe7_\\xbbb\"x\\xbd\\x12\\xb73\\xbc~\\xfd\\x83;\\'\\x04N=\\x19c\\r=P\\xa0\\xd3;jI\\x18\\xbd\\xc0n\\xb2=\\x9c\\x16%\\xbdtU\\xec=\\xbe\\xd9V\\xbde\\x00W\\xbc\\xb3\\x1e\\xb9\\xbb\\xd8L\\x82\\xbd6\\x82K\\xbc\\xef\\xd1\\x0e\\xbd;\\\\\\xef;&r\\xe3\\xbc\\xf9#\\xc7\\xbcH\\xc1\\xca\\xb2\\xcd\\x83\\xec\\xbd\\t\\xe1\\x08\\xbd\\xd3,\\x80\\xbb\\xd2v\\xf4\\xbd\\x11\\xa5\\xd7\\xbbJ\\xd6\\xc3<\\x1a`;\\xbd\\x07\\xab6\\xbc\\x91\\tM\\xbd\\xfe\\xba\\x95=\\x1e\\x15\\xa8;\\x04\\x84\\x91<0\\x02\\xa4=\\xea\\xf8\\xec<HIj=H\\x16\\x9d=\\x0cf\\x01\\xbeU\\x05V\\xbdz]\\xac\\xbdcr\\xda\\xbd\\xfeg=\\xbdm\\x01!\\xbdX\\x95#=t\\xbf\\x05=\\x1f\\xd5\\xad<\\rM\\xb3=\\xbf\\xbc\\x91\\xbd\\xd2<\\xcf</\\x7f\\x9b=\\xf5\\xd7\\xbc=\\xb4\\x9f\\xd5\\xbc\\xe5-\\x15\\xbd\\x88S\\xa7\\xbd%.\\x1f<\\x91v\\x03>\\xc0XB=L\\xb5\\x99\\xbb\\x086\\x90\\xbc\\xab\\x99\\x98=\\x8a\\xb16\\xbc\\xcaE\\xba\\xbd\\x93\\x93W=\\xe7\\r\\xe9<\\xbf\\xb7\\x8e=\\xf0X\\xa9=\\xf2;\\x18\\xba{U\\x15\\xbd\\xefH\\x00\\xbd\\x12g\\xa2;\\x81\\xb0\\xb3\\xbd\\x8f\\x8c =T\\x7fv\\xbb\\x08y\\x84\\xbc\\xba\\'\\xd8\\xba1\\x92\\xa5\\xbc5\\x1b)\\xbc\\x803\\xae\\xbb\"O\\x95<\\xe4\\x82\\x9d\\xbc{O\\x08<ck\\x93\\xbbA \\xe7\\xba;\\x94\\x82=\\xeb9\\n='}]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "movie_data[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define Redis index schema\n",
    "\n",
    "Below, we build a schema that represents our movie objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12:50:10 redisvl.index.index INFO   Index already exists, overwriting.\n"
     ]
    }
   ],
   "source": [
    "from redisvl.schema import IndexSchema\n",
    "from redisvl.index import SearchIndex\n",
    "\n",
    "\n",
    "schema = IndexSchema.from_dict({\n",
    "  \"index\": {\n",
    "    \"name\": \"movies\",\n",
    "    \"prefix\": \"movie\",\n",
    "    \"storage\": \"hash\"\n",
    "  },\n",
    "  \"fields\": [\n",
    "    { \"name\": \"title\", \"type\": \"text\" },\n",
    "    { \"name\": \"description\", \"type\": \"text\" },\n",
    "    { \"name\": \"genre\", \"type\": \"tag\", \"attrs\": {\"sortable\": True}},\n",
    "    { \"name\": \"rating\", \"type\": \"numeric\", \"attrs\": {\"sortable\": True}},\n",
    "    {\n",
    "        \"name\": \"description_vector\",\n",
    "        \"type\": \"vector\",\n",
    "        \"attrs\": {\n",
    "            \"dims\": 384,\n",
    "            \"distance_metric\": \"cosine\",\n",
    "            \"algorithm\": \"hnsw\",\n",
    "            \"datatype\": \"float32\"\n",
    "        }\n",
    "    }\n",
    "  ]\n",
    "})\n",
    "\n",
    "\n",
    "index = SearchIndex(schema, client)\n",
    "index.create(overwrite=True, drop=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Populate index\n",
    "\n",
    "Load movie objects into Redis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['movie:0d8537e75af24af6b118f4629c2758a3',\n",
       " 'movie:28c6547937a7402cba307cbe113c322f',\n",
       " 'movie:d9bb23e83e1c41ad89f5de18ea5c65d6',\n",
       " 'movie:b1d51e082d954d2eb00690885b601e76',\n",
       " 'movie:54c806022aae415b9e1e23a110ca78d4',\n",
       " 'movie:b81aad8ca262422cb80ba725b17afce4',\n",
       " 'movie:54501580991a4e509194de51e9243159',\n",
       " 'movie:1b184aed092e4a83a9b9ff15ae38b9b3',\n",
       " 'movie:2b57e7ff370347528f0d1007bf7b9efd',\n",
       " 'movie:ff0a1ca4f858447aab548bd9e12106cf',\n",
       " 'movie:b0d7a84540f644099f411e7a5e2324c2',\n",
       " 'movie:563bc43778494fe49ecb4884c20a0015',\n",
       " 'movie:317ca39cce5e4817a153fa24821c83dc',\n",
       " 'movie:ae506669d2fb47988398b6ea70c76a43',\n",
       " 'movie:22c9dd9473104cde933a8d7918818fd5',\n",
       " 'movie:dba67e0f8f4f45e38ba58533a7e70ec3',\n",
       " 'movie:2f6abe9b28034db58e37d9b3cf4b0e96',\n",
       " 'movie:64282c7d9f654e2d9c607a025ca25f2f',\n",
       " 'movie:88b925781ac84dceb267ab92015450f1',\n",
       " 'movie:8db639fc4fc44771b8e3285bf6a236e8']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index.load(movie_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hybrid Search Approaches\n",
    "\n",
    "Now that our search index is populated and ready, we will build out a few different hybrid search techniques in Redis.\n",
    "\n",
    "To start, we will build a few helper methods that we can reuse for each technique."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sample user query (can be changed for comparisons)\n",
    "user_query = \"action adventure movie with great fighting scenes, crime busting, superheroes, and magic\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we need a method to tokenize a user query into a full-text search string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'action | adventure | movie | great | fighting | scenes | crime | busting | superheroes | magic'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list of stopwords to filter out noise from query string\n",
    "stopwords = set([\n",
    "    \"a\", \"is\", \"the\", \"an\", \"and\", \"are\", \"as\", \"at\", \"be\", \"but\", \"by\", \"for\",\n",
    "    \"if\", \"in\", \"into\", \"it\", \"no\", \"not\", \"of\", \"on\", \"or\", \"such\", \"that\", \"their\",\n",
    "    \"then\", \"there\", \"these\", \"they\", \"this\", \"to\", \"was\", \"will\", \"with\"\n",
    "])\n",
    "\n",
    "def tokenize_query(user_query: str) -> str:\n",
    "    \"\"\"Convert a raw user query to a redis full text query joined by ORs\"\"\"\n",
    "    tokens = [token.strip().strip(\",\").lower() for token in user_query.split()]\n",
    "    return \" | \".join([token for token in tokens if token not in stopwords])\n",
    "\n",
    "# Example\n",
    "tokenize_query(user_query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we need methods to create vector search and full-text search queries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to create a vector query using RedisVL helpers for ease of use\n",
    "from redisvl.query import VectorQuery, FilterQuery\n",
    "from redisvl.query.filter import Text\n",
    "from redisvl.redis.utils import convert_bytes, make_dict\n",
    "\n",
    "\n",
    "def make_vector_query(user_query: str, num_results: int, filters = None) -> VectorQuery:\n",
    "    \"\"\"Generate a Redis vector query given user query string.\"\"\"\n",
    "    vector = model.embed(user_query, as_buffer=True, dtype=\"float32\")\n",
    "    query = VectorQuery(\n",
    "        vector=vector,\n",
    "        vector_field_name=\"description_vector\",\n",
    "        num_results=num_results,\n",
    "        return_fields=[\"title\", \"description\"]\n",
    "    )\n",
    "    if filters:\n",
    "        query.set_filter(filters)\n",
    "    \n",
    "    return query\n",
    "\n",
    "\n",
    "def make_ft_query(text_field: str, user_query: str, num_results: int) -> FilterQuery:\n",
    "    \"\"\"Generate a Redis full-text query given a user query string.\"\"\"\n",
    "    return FilterQuery(\n",
    "        filter_expression=f\"~({Text(text_field) % tokenize_query(user_query)})\",\n",
    "        num_results=num_results,\n",
    "        return_fields=[\"title\", \"description\"],\n",
    "        dialect=4,\n",
    "    ).scorer(\"BM25\").with_scores()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Linear Combination using Aggregation API\n",
    "\n",
    "The goal of this technique is to calculate a weighted sum of the BM25 score for our provided text search and the cosine distance between vectors calculated via a KNN vector query. This is possible in Redis using the [aggregations API](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/aggregations/), as of `Redis 7.4.x` (search version `2.10.5`), within a single database call.\n",
    "\n",
    "In Redis, the aggregations api allow you the ability to group, sort, and transform your result data in the ways you might expect to be able to do with groupby and sums in other database paradigms.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we build a base `VectorQuery` that runs a KNN-style vector search and test it below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'id': 'movie:dba67e0f8f4f45e38ba58533a7e70ec3',\n",
       "  'vector_distance': '0.643690049648',\n",
       "  'title': 'The Incredibles',\n",
       "  'description': \"A family of undercover superheroes, while trying to live the quiet suburban life, are forced into action to save the world. Bob Parr (Mr. Incredible) and his wife Helen (Elastigirl) were among the world's greatest crime fighters, but now they must assume civilian identities and retreat to the suburbs to live a 'normal' life with their three children. However, the family's desire to help the world pulls them back into action when they face a new and dangerous enemy.\"},\n",
       " {'id': 'movie:0d8537e75af24af6b118f4629c2758a3',\n",
       "  'vector_distance': '0.668439269066',\n",
       "  'title': 'Explosive Pursuit',\n",
       "  'description': 'A daring cop chases a notorious criminal across the city in a high-stakes game of cat and mouse.'},\n",
       " {'id': 'movie:b81aad8ca262422cb80ba725b17afce4',\n",
       "  'vector_distance': '0.698122382164',\n",
       "  'title': 'Mad Max: Fury Road',\n",
       "  'description': \"In a post-apocalyptic wasteland, Max teams up with Furiosa to escape a tyrant's clutches and find freedom.\"}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "query = make_vector_query(user_query, num_results=3)\n",
    "\n",
    "# Check standard vector search results\n",
    "index.query(query)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we add a full-text search predicate using RedisVL helpers and our user-query tokenizer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(~@description:(action | adventure | movie | great | fighting | scenes | crime | busting | superheroes | magic))=>[KNN 3 @description_vector $vector AS vector_distance]'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base_full_text_query = str(Text(\"description\") % tokenize_query(user_query))\n",
    "\n",
    "# Add the optional flag, \"~\", so that this doesn't also act as a strict text filter\n",
    "full_text_query = f\"(~{base_full_text_query})\"\n",
    "\n",
    "\n",
    "# Add full-text predicate to the vector query \n",
    "query.set_filter(full_text_query)\n",
    "query.query_string()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**The query string above combines both full-text search and a vector search.** This will be passed to the aggregation API to combine using a simple weighted sum of scores before a final sort and truncation.\n",
    "\n",
    "Note: for the following query to work `redis-py >= 5.2.0`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'vector_distance': '0.643690049648',\n",
       "  '__score': '0.968066079387',\n",
       "  'title': 'The Incredibles',\n",
       "  'description': \"A family of undercover superheroes, while trying to live the quiet suburban life, are forced into action to save the world. Bob Parr (Mr. Incredible) and his wife Helen (Elastigirl) were among the world's greatest crime fighters, but now they must assume civilian identities and retreat to the suburbs to live a 'normal' life with their three children. However, the family's desire to help the world pulls them back into action when they face a new and dangerous enemy.\",\n",
       "  'cosine_similarity': '0.678154975176',\n",
       "  'bm25_score': '0.968066079387',\n",
       "  'hybrid_score': '0.765128306439'},\n",
       " {'vector_distance': '0.668439269066',\n",
       "  '__score': '0',\n",
       "  'title': 'Explosive Pursuit',\n",
       "  'description': 'A daring cop chases a notorious criminal across the city in a high-stakes game of cat and mouse.',\n",
       "  'cosine_similarity': '0.665780365467',\n",
       "  'bm25_score': '0',\n",
       "  'hybrid_score': '0.466046255827'},\n",
       " {'vector_distance': '0.698122382164',\n",
       "  '__score': '0',\n",
       "  'title': 'Mad Max: Fury Road',\n",
       "  'description': \"In a post-apocalyptic wasteland, Max teams up with Furiosa to escape a tyrant's clutches and find freedom.\",\n",
       "  'cosine_similarity': '0.650938808918',\n",
       "  'bm25_score': '0',\n",
       "  'hybrid_score': '0.455657166243'}]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from typing import Any, Dict, List\n",
    "from redis.commands.search.aggregation import AggregateRequest, Desc\n",
    "\n",
    "# Build the aggregation request\n",
    "req = (\n",
    "    AggregateRequest(query.query_string())\n",
    "        .scorer(\"BM25\")\n",
    "        .add_scores()\n",
    "        .apply(cosine_similarity=\"(2 - @vector_distance)/2\", bm25_score=\"@__score\")\n",
    "        .apply(hybrid_score=f\"0.3*@bm25_score + 0.7*@cosine_similarity\")\n",
    "        .load(\"title\", \"description\", \"cosine_similarity\", \"bm25_score\", \"hybrid_score\")\n",
    "        .sort_by(Desc(\"@hybrid_score\"), max=3)\n",
    "        .dialect(4)\n",
    ")\n",
    "\n",
    "# Run the query\n",
    "res = index.aggregate(req, query_params={'vector': query._vector})\n",
    "\n",
    "# Perform output parsing\n",
    "[make_dict(row) for row in convert_bytes(res.rows)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notes on aggregate query syntax \n",
    "- `.scorer`: specifies the scoring function to use BM25 in this case\n",
    "    - [see docs](https://redis.io/docs/latest/develop/interact/search-and-query/advanced-concepts/scoring/) for all available scorers\n",
    "- `.add_scores`: adds the scores to the result\n",
    "- `.apply`: algebraic operations that can be customized for your use case\n",
    "- `.load`: specifies fields to return - all in this case.\n",
    "- `.sort_by`: sort the output based on the hybrid score and yield top 5 results\n",
    "- `.dialect`: specifies the query dialect to use."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will define a function to do the entire operation start to finish for simplicity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_combo(user_query: str, alpha: float, num_results: int = 3) -> List[Dict[str, Any]]:\n",
    "    # Add the optional flag, \"~\", so that this doesn't also act as a strict text filter\n",
    "    text = f\"(~{Text('description') % tokenize_query(user_query)})\"\n",
    "\n",
    "    # Build vector query\n",
    "    query = make_vector_query(user_query, num_results=num_results, filters=text)\n",
    "    \n",
    "    # Build aggregation\n",
    "    req = (\n",
    "        AggregateRequest(query.query_string())\n",
    "            .scorer(\"BM25\")\n",
    "            .add_scores()\n",
    "            .apply(cosine_similarity=\"(2 - @vector_distance)/2\", bm25_score=\"@__score\")\n",
    "            .apply(hybrid_score=f\"{1-alpha}*@bm25_score + {alpha}*@cosine_similarity\")\n",
    "            .sort_by(Desc(\"@hybrid_score\"), max=num_results)\n",
    "            .load(\"title\", \"description\", \"cosine_similarity\", \"bm25_score\", \"hybrid_score\")\n",
    "            .dialect(4)\n",
    "    )\n",
    "\n",
    "    # Run the query\n",
    "    res = index.aggregate(req, query_params={'vector': query._vector})\n",
    "\n",
    "    # Perform output parsing\n",
    "    if res:\n",
    "        movies = [make_dict(row) for row in convert_bytes(res.rows)]\n",
    "        return [(movie[\"title\"], movie[\"hybrid_score\"]) for movie in movies]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The Incredibles', '0.765128306439'),\n",
       " ('Explosive Pursuit', '0.466046255827'),\n",
       " ('Mad Max: Fury Road', '0.455657166243'),\n",
       " ('The Dark Knight', '0.452280691266'),\n",
       " ('Despicable Me', '0.448826777935'),\n",
       " ('Inception', '0.434456580877')]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it out\n",
    "\n",
    "# 70% of the hybrid search score based on cosine similarity\n",
    "linear_combo(user_query, alpha=0.7, num_results=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Client-side fusion with RRF\n",
    "\n",
    "Instead of relying on document scores like cosine similarity and BM25/TFIDF, we can fetch items and focus on their rank. This rank can be utilized to create a new ranking metric known as [Reciprocal Rank Fusion (RRF)](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf). RRF is powerful because it can handle ranked lists of different length, scores of different scales, and other complexities.\n",
    "\n",
    "Although Redis does not currently support RRF natively, we can easily implement it on the client side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fuse_rankings_rrf(*ranked_lists, weights=None, k=60):\n",
    "    \"\"\"\n",
    "    Perform Weighted Reciprocal Rank Fusion on N number of ordered lists.\n",
    "    \"\"\"\n",
    "    item_scores = {}\n",
    "    \n",
    "    if weights is None:\n",
    "        weights = [1.0] * len(ranked_lists)\n",
    "    else:\n",
    "        assert len(weights) == len(ranked_lists), \"Number of weights must match number of ranked lists\"\n",
    "        assert all(0 <= w <= 1 for w in weights), \"Weights must be between 0 and 1\"\n",
    "    \n",
    "    for ranked_list, weight in zip(ranked_lists, weights):\n",
    "        for rank, item in enumerate(ranked_list, start=1):\n",
    "            if item not in item_scores:\n",
    "                item_scores[item] = 0\n",
    "            item_scores[item] += weight * (1 / (rank + k))\n",
    "    \n",
    "    # Sort items by their weighted RRF scores in descending order\n",
    "    return sorted(item_scores.items(), key=lambda x: x[1], reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(2, 0.04814747488101534),\n",
       " (1, 0.032266458495966696),\n",
       " (6, 0.03200204813108039),\n",
       " (5, 0.01639344262295082),\n",
       " (4, 0.016129032258064516),\n",
       " (3, 0.015873015873015872),\n",
       " (7, 0.015625),\n",
       " (8, 0.015384615384615385)]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Below is a simple example of RRF over a few lists of numbers\n",
    "fuse_rankings_rrf([1, 2, 3], [2, 4, 6, 7, 8], [5, 6, 1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def weighted_rrf(\n",
    "    user_query: str,\n",
    "    alpha: float = 0.5,\n",
    "    num_results: int = 4,\n",
    "    k: int = 60,\n",
    ") -> List[Dict[str, Any]]:\n",
    "    \"\"\"Implemented client-side RRF after querying from Redis.\"\"\"\n",
    "    # Create the vector query\n",
    "    vector_query = make_vector_query(user_query, num_results=len(movie_data))\n",
    "\n",
    "    # Create the full-text query\n",
    "    full_text_query = make_ft_query(\"description\", user_query, num_results=len(movie_data))\n",
    "\n",
    "    # Run queries individually\n",
    "    vector_query_results = index.query(vector_query)\n",
    "    full_text_query_results = index.query(full_text_query)\n",
    "\n",
    "    # Extract titles from results\n",
    "    vector_titles = [movie[\"title\"] for movie in vector_query_results]\n",
    "    full_text_titles = [movie[\"title\"] for movie in full_text_query_results]\n",
    "\n",
    "    # Perform weighted RRF\n",
    "    return fuse_rankings_rrf(vector_titles, full_text_titles, weights=[alpha, 1-alpha], k=k)[:num_results]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The Incredibles', 0.016009221311475412),\n",
       " ('Explosive Pursuit', 0.01575682382133995),\n",
       " ('Mad Max: Fury Road', 0.015079365079365078),\n",
       " ('Finding Nemo', 0.015008960573476702),\n",
       " ('Fast & Furious 9', 0.014925373134328358),\n",
       " ('The Dark Knight', 0.014854753521126762)]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it out!\n",
    "weighted_rrf(user_query, num_results=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But say we want to give more weight to the vector search rankings in this case to boost semantic similarities contribution to the final rank:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The Incredibles', 0.016162909836065574),\n",
       " ('Explosive Pursuit', 0.015905707196029777),\n",
       " ('Mad Max: Fury Road', 0.015396825396825395),\n",
       " ('The Dark Knight', 0.015162852112676057),\n",
       " ('Fast & Furious 9', 0.014925373134328356),\n",
       " ('Inception', 0.014715649647156496)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weighted_rrf(user_query, alpha=0.7, num_results=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Client-side reranking\n",
    "\n",
    "An alternative approach to RRF is to simply use an external reranker to order the final recommendations. RedisVL has built-in integrations to a few popular reranking modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "349ccd5a976f4283866adfc290ab85ea",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "config.json:   0%|          | 0.00/794 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1c623c924cef45a5969e05b2d4c8b1c0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "pytorch_model.bin:   0%|          | 0.00/90.9M [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f3af1903adec4f3389ad0b467e1d0084",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "tokenizer_config.json:   0%|          | 0.00/316 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8a305a62d59243cf820f4ea3b547a855",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7fc2aae755304ba99352ef0a74b50102",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "special_tokens_map.json:   0%|          | 0.00/112 [00:00<?, ?B/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from redisvl.utils.rerank import HFCrossEncoderReranker\n",
    "\n",
    "# Load the ms marco MiniLM cross encoder model from huggingface\n",
    "reranker = HFCrossEncoderReranker(\"cross-encoder/ms-marco-MiniLM-L-6-v2\")\n",
    "\n",
    "\n",
    "def rerank(\n",
    "    user_query: str,\n",
    "    num_results: int = 4,\n",
    ") -> List[Dict[str, Any]]:\n",
    "    \"\"\"Rerank the candidates based on the user query with an external model/module.\"\"\"\n",
    "    # Create the vector query\n",
    "    vector_query = make_vector_query(user_query, num_results=num_results)\n",
    "\n",
    "    # Create the full-text query\n",
    "    full_text_query = make_ft_query(\"description\", user_query, num_results=num_results)\n",
    "\n",
    "    # Run queries individually\n",
    "    vector_query_results = index.query(vector_query)\n",
    "    full_text_query_results = index.query(full_text_query)\n",
    "\n",
    "    # Assemble list of potential movie candidates with their IDs\n",
    "    movie_map = {}\n",
    "    for movie in vector_query_results + full_text_query_results:\n",
    "        candidate = f\"Title: {movie['title']}. Description: {movie['description']}\"\n",
    "        if candidate not in movie_map:\n",
    "            movie_map[candidate] = movie\n",
    "\n",
    "    # Rerank candidates\n",
    "    reranked_movies, scores = reranker.rank(\n",
    "        query=user_query,\n",
    "        docs=list(movie_map.keys()),\n",
    "        limit=num_results,\n",
    "        return_score=True\n",
    "    )\n",
    "\n",
    "    # Fetch full movie objects for the reranked results\n",
    "    return [\n",
    "        (movie_map[movie['content']][\"title\"], score)\n",
    "        for movie, score in zip(reranked_movies, scores)\n",
    "    ]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('The Incredibles', -0.45268189907073975),\n",
       " ('The Dark Knight', -7.411877632141113),\n",
       " ('Explosive Pursuit', -8.751346588134766),\n",
       " ('Mad Max: Fury Road', -7.049145698547363),\n",
       " ('Aladdin', -9.638406753540039),\n",
       " ('Despicable Me', -9.797615051269531)]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Test it out!\n",
    "rerank(user_query, num_results=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This technique is certainly much slower than simple RRF as it's running an additional cross-encoder model to rerank the results. This can be fairly computationally expensive, but tunable with enough clarity on the use case and focus (how many items to retrieve? how many items to rerank? model accleration via GPU?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing Approaches\n",
    "\n",
    "While each approach has strengths and weaknesses, it's important to understand that each might work better in some use cases than others. Below we will run through a sample of user queries and generate matches for each using different hybrid search techniques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "movie_user_queries = [\n",
    "    \"I'm in the mood for a high-rated action movie with a complex plot\",\n",
    "    \"What's a funny animated film about unlikely friendships?\",\n",
    "    \"Any movies featuring superheroes or extraordinary abilities\", \n",
    "    \"I want to watch a thrilling movie with spies or secret agents\",\n",
    "    \"Are there any comedies set in unusual locations or environments?\",\n",
    "    \"Find me an action-packed movie with car chases or explosions\",\n",
    "    \"What's a good family-friendly movie with talking animals?\",\n",
    "    \"I'm looking for a film that combines action and mind-bending concepts\",\n",
    "    \"Suggest a movie with a strong female lead character\",\n",
    "    \"What are some movies that involve heists or elaborate plans?\",\n",
    "    \"I need a feel-good movie about personal growth or transformation\",\n",
    "    \"Are there any films that blend comedy with action elements?\", \n",
    "    \"Show me movies set in dystopian or post-apocalyptic worlds\",\n",
    "    \"I'm interested in a movie with themes of revenge or justice\",\n",
    "    \"What are some visually stunning movies with impressive special effects?\"\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "\n",
    "rankings = pd.DataFrame()\n",
    "rankings[\"queries\"] = movie_user_queries\n",
    "\n",
    "# First, add new columns to the DataFrame\n",
    "rankings[\"hf-cross-encoder\"] = \"\"\n",
    "rankings[\"rrf\"] = \"\"\n",
    "rankings[\"linear-combo-bm25-cosine\"] = \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now iterate through the queries and add results\n",
    "for i, user_query in enumerate(movie_user_queries):\n",
    "    rankings.at[i, \"hf-cross-encoder\"] = rerank(user_query, num_results=4)\n",
    "    rankings.at[i, \"rrf\"] = weighted_rrf(user_query, alpha=0.7, num_results=4)\n",
    "    rankings.at[i, \"linear-combo-bm25-cosine\"] = linear_combo(user_query, alpha=0.7, num_results=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>queries</th>\n",
       "      <th>hf-cross-encoder</th>\n",
       "      <th>rrf</th>\n",
       "      <th>linear-combo-bm25-cosine</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>I'm in the mood for a high-rated action movie ...</td>\n",
       "      <td>[(Explosive Pursuit, -11.244140625), (Mad Max:...</td>\n",
       "      <td>[(The Incredibles, 0.016029143897996357), (Mad...</td>\n",
       "      <td>[(The Incredibles, 0.552392209158), (Despicabl...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>What's a funny animated film about unlikely fr...</td>\n",
       "      <td>[(Despicable Me, -10.441911697387695), (The In...</td>\n",
       "      <td>[(Black Widow, 0.015625), (The Incredibles, 0....</td>\n",
       "      <td>[(The Incredibles, 0.454752022028), (Despicabl...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Any movies featuring superheroes or extraordin...</td>\n",
       "      <td>[(The Incredibles, -3.6648106575012207), (The ...</td>\n",
       "      <td>[(The Incredibles, 0.01639344262295082), (Mad ...</td>\n",
       "      <td>[(The Incredibles, 0.603234936448), (The Aveng...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>I want to watch a thrilling movie with spies o...</td>\n",
       "      <td>[(The Incredibles, -10.843631744384766), (Expl...</td>\n",
       "      <td>[(Skyfall, 0.01631411951348493), (Explosive Pu...</td>\n",
       "      <td>[(Skyfall, 0.44384047389), (Despicable Me, 0.4...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Are there any comedies set in unusual location...</td>\n",
       "      <td>[(The Incredibles, -11.45376968383789), (Explo...</td>\n",
       "      <td>[(Madagascar, 0.015272878190495952), (Explosiv...</td>\n",
       "      <td>[(Madagascar, 0.442132177949), (Despicable Me,...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                             queries  \\\n",
       "0  I'm in the mood for a high-rated action movie ...   \n",
       "1  What's a funny animated film about unlikely fr...   \n",
       "2  Any movies featuring superheroes or extraordin...   \n",
       "3  I want to watch a thrilling movie with spies o...   \n",
       "4  Are there any comedies set in unusual location...   \n",
       "\n",
       "                                    hf-cross-encoder  \\\n",
       "0  [(Explosive Pursuit, -11.244140625), (Mad Max:...   \n",
       "1  [(Despicable Me, -10.441911697387695), (The In...   \n",
       "2  [(The Incredibles, -3.6648106575012207), (The ...   \n",
       "3  [(The Incredibles, -10.843631744384766), (Expl...   \n",
       "4  [(The Incredibles, -11.45376968383789), (Explo...   \n",
       "\n",
       "                                                 rrf  \\\n",
       "0  [(The Incredibles, 0.016029143897996357), (Mad...   \n",
       "1  [(Black Widow, 0.015625), (The Incredibles, 0....   \n",
       "2  [(The Incredibles, 0.01639344262295082), (Mad ...   \n",
       "3  [(Skyfall, 0.01631411951348493), (Explosive Pu...   \n",
       "4  [(Madagascar, 0.015272878190495952), (Explosiv...   \n",
       "\n",
       "                            linear-combo-bm25-cosine  \n",
       "0  [(The Incredibles, 0.552392209158), (Despicabl...  \n",
       "1  [(The Incredibles, 0.454752022028), (Despicabl...  \n",
       "2  [(The Incredibles, 0.603234936448), (The Aveng...  \n",
       "3  [(Skyfall, 0.44384047389), (Despicable Me, 0.4...  \n",
       "4  [(Madagascar, 0.442132177949), (Despicable Me,...  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rankings.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Show me movies set in dystopian or post-apocalyptic worlds',\n",
       "       list([('Mad Max: Fury Road', -3.490626335144043), ('Despicable Me', -11.051526069641113), ('The Incredibles', -11.315656661987305), ('Black Widow', -10.880638122558594)]),\n",
       "       list([('Mad Max: Fury Road', 0.01602086438152012), ('Skyfall', 0.015607940446650124), ('The Incredibles', 0.015237691001697792), ('Black Widow', 0.01513526119402985)]),\n",
       "       list([('Mad Max: Fury Road', '0.452238571644'), ('The Incredibles', '0.445061546564'), ('Madagascar', '0.41901564002'), ('Despicable Me', '0.416218408942')])],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rankings.loc[12].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wrap up\n",
    "That's a wrap! Hopefully from this you were able to learn:\n",
    "- How to implement simple vector search queries in Redis\n",
    "- How to implement vector search queries with full-text filters\n",
    "- How to implement hybrid search queries using the Redis aggregation API\n",
    "- How to perform client-side fusion and reranking techniques"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}