qdrant_101_getting_started/getting_started.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started with Qdrant"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vector databases shine in many applications like [semantic search](https://en.wikipedia.org/wiki/Semantic_search) and [recommendation systems](https://en.wikipedia.org/wiki/Recommender_system), and in this tutorial, you will learn how to get started building such systems with one of the most popular and fastest growing vector databases in the market, [Qdrant](qdrant.tech)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of contents"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Learning Outcomes](##-1.-Learning-Outcomes)\n",
    "2. [Installation](##-2.-Installation)\n",
    "3. [Getting Started](##-3.-Getting-Started)\n",
    "    - [Adding Points](###-3.1-Adding-Points)\n",
    "    - [Payload](###-3.2-Payloads)\n",
    "    - [Search](###-3.3-Search)\n",
    "4. [Recommendations](##-4.-Recommendations)\n",
    "5. [Conclusion](##-5.-Conclusion)\n",
    "6. [Resources](##-6.-Resources)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Learning outcomes"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By the end of this tutorial, you will be able to: \n",
    "- Create, update, and query collections of vectors using Qdrant.\n",
    "- Conduct semantic search based on new data.\n",
    "- Develop an intuition for the mechanics behind the recommendation API of Qdrant.\n",
    "- Understand and get creative with the kind of data you can add to your payload."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Installation"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The open source version of Qdrant is available as a Docker image. You can download the image and run it from any machine with Docker installed on it. If you don't have Docker installed, follow the instructions [here](https://docs.docker.com/get-docker/). After you have installed Docker, Terminal and download the Qdrant image:\n",
    "\n",
    "```sh\n",
    "docker pull qdrant/qdrant\n",
    "```\n",
    "\n",
    "Next, initialize Qdrant:\n",
    "\n",
    "```sh\n",
    "docker run -p 6333:6333 \\\n",
    "    -v $(pwd)/qdrant_storage:/qdrant/storage \\\n",
    "    qdrant/qdrant\n",
    "```\n",
    "\n",
    "You should see something like this:\n",
    "\n",
    "![dockerqdrant](img/docker_qdrant_28_10_2023.png)\n",
    "\n",
    "If you experience any issues during installation, please let us know in our [Discord channel here](https://qdrant.to/discord). \n",
    "\n",
    "Now that you have Qdrant up and running, you need to pick a client to connect to it. We'll be using Python as it has the most mature data tools ecosystem out there. Let's start setting up our development environment and getting the libraries we'll be using.\n",
    "\n",
    "**Note:** At the time of writing, Qdrant supports Rust, Go, Python TypeScript, Java and C#. We expect other programming languages to be added in the future."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip install qdrant-client pandas numpy faker"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Getting started"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The two modules we are going to use are `QdrantClient` and `models`. The former lets you connect to Qdrant or to run an in-memory database by switching the parameter `location=` to `\":memory:\"`. The latter gives you access to most functionalities you need to interact with Qdrant. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qdrant_client import QdrantClient\n",
    "from qdrant_client import models\n",
    "from qdrant_client.models import CollectionStatus"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll start by instantiating our client using `host=\"localhost\"` and `port=6333` (as it is the default port we used earlier with Docker). You can also follow along with the `location=\":memory:\"` option commented out below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<qdrant_client.qdrant_client.QdrantClient at 0x1079a1710>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client = QdrantClient(host=\"localhost\", port=6333)\n",
    "client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# client = QdrantClient(location=\":memory:\")\n",
    "# client"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Note:** In OLTP and OLAP databases we call specific bundles of rows and columns **Tables**. However, in vector databases, the rows are known as **Vectors**, while the columns are **Dimensions**. The combination of the two (plus some metadata) is a [**Collection**](https://qdrant.tech/documentation/concepts/collections/).\n",
    "\n",
    "Just as we can create many tables in an OLTP or an OLAP database, we can create many collections in a vector database like Qdrant using one of its clients. The key difference to note is that when we create a collection in Qdrant, we need to specify the width of the collection (i.e. the length of the vector or amount of dimensions) beforehand with the parameter `size=...`, as well as the distance metric with the parameter `distance=...`.\n",
    "\n",
    "The distances currently supported by Qdrant are [**Cosine Similarity**](https://en.wikipedia.org/wiki/Cosine_similarity), [**Dot Product**](https://en.wikipedia.org/wiki/Dot_product), and [**Euclidean Distance**](https://en.wikipedia.org/wiki/Euclidean_distance).\n",
    "\n",
    "---"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create our first collection and have the vectors be of size 100 with a distance set to **Cosine Similarity**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/wf/617k9yhn1875htvkfrd0rmmw0000gn/T/ipykernel_70021/1220860614.py:3: DeprecationWarning: `recreate_collection` method is deprecated and will be removed in the future. Use `collection_exists` to check collection existence and `create_collection` instead.\n",
      "  first_collection = client.recreate_collection(\n"
     ]
    }
   ],
   "source": [
    "my_collection = \"first_collection\"\n",
    "\n",
    "first_collection = client.recreate_collection(\n",
    "    collection_name=my_collection,\n",
    "    vectors_config=models.VectorParams(size=100, distance=models.Distance.COSINE)\n",
    ")\n",
    "print(first_collection)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract information related to the health of our collection by retrieving the collection with our client. In addition, we can use this information for testing purposes, which can be very beneficial while in development mode."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('status', <CollectionStatus.GREEN: 'green'>),\n",
       " ('optimizer_status', <OptimizersStatusOneOf.OK: 'ok'>),\n",
       " ('vectors_count', None),\n",
       " ('indexed_vectors_count', 0),\n",
       " ('points_count', 0),\n",
       " ('segments_count', 8),\n",
       " ('config',\n",
       "  CollectionConfig(params=CollectionParams(vectors=VectorParams(size=100, distance=<Distance.COSINE: 'Cosine'>, hnsw_config=None, quantization_config=None, on_disk=None, datatype=None, multivector_config=None), shard_number=1, sharding_method=None, replication_factor=1, write_consistency_factor=1, read_fan_out_factor=None, on_disk_payload=True, sparse_vectors=None), hnsw_config=HnswConfig(m=16, ef_construct=100, full_scan_threshold=10000, max_indexing_threads=0, on_disk=False, payload_m=None), optimizer_config=OptimizersConfig(deleted_threshold=0.2, vacuum_min_vector_number=1000, default_segment_number=0, max_segment_size=None, memmap_threshold=None, indexing_threshold=20000, flush_interval_sec=5, max_optimization_threads=None), wal_config=WalConfig(wal_capacity_mb=32, wal_segments_ahead=0), quantization_config=None)),\n",
       " ('payload_schema', {})]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collection_info = client.get_collection(collection_name=my_collection)\n",
    "list(collection_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert collection_info.status == CollectionStatus.GREEN\n",
    "assert collection_info.points_count == 0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two important takeaways:\n",
    "\n",
    "1. When you initiated the Docker image, you created a local directory called, `qdrant_storage`. This is where all of your collections and their metadata will be stored. \n",
    "\n",
    "    Qdrant can use one of two options for [storage](https://qdrant.tech/documentation/concepts/storage/): \n",
    "    - **in-memory** storage, which stores all vectors in RAM and has the highest speed since disk access is required only for persistence)\n",
    "    - **memmap** storage, which creates a virtual address space associated with the file on disk. You can have a look at that directory in a *nix system with `tree qdrant_storage -L 2`, and something similar to the following output should come up for you.\n",
    "\n",
    "        ```bash\n",
    "        qdrant_storage\n",
    "        ├── aliases\n",
    "        │   └── data.json\n",
    "        ├── collections\n",
    "        │   └── my_first_collection\n",
    "        └── raft_state\n",
    "        ```\n",
    "    \n",
    "2. You used `client.recreate_collection()`, which can be used more than once to create new collections with or without the same name. Therefore, please make sure you do not run this command multiple times and accidentally recreate a collection. \n",
    "\n",
    "Instead, to create a brand new collection that cannot be recreated, use the `client.create_collection()` method.\n",
    "\n",
    "The created collection will hold vectors of 100 dimensions and the distance metric has been set to Cosine Similarity.\n",
    "\n",
    "Now that we know how to create collections, let's create a bit of dummy data and add some vectors to it."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 Adding points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Points](https://qdrant.tech/documentation/concepts/points/) are a central entity that Qdrant operates with. They contain records consisting of a vector, an optional `id`, and an optional `payload`.\n",
    "\n",
    "The optional id can be represented by [unsigned integers](https://en.wikipedia.org/wiki/Integer_(computer_science)) or [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier)s. For this tutorial, we will use a straightforward range of numbers.\n",
    "\n",
    "You can use [NumPy](https://numpy.org/) to create a matrix of dummy data containing 1,000 vectors and 100 dimensions.  Then, you can represent the values as `float64` numbers between -1 and 1. For simplicity, imagine that each of these vectors represents one of our favorite songs. Then, each column would represent a unique characteristic of the song; e.g. the tempo, the beats, the pitch of the voice(s) of the singer(s)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.float64,\n",
       " array([[-0.42821695, -0.0140057 , -0.48015149,  0.2772616 ,  0.49262215,\n",
       "          0.92767383,  0.34668525,  0.13876603,  0.45314349,  0.04778376,\n",
       "          0.54183112,  0.62803171, -0.28792279,  0.13449526, -0.74653784,\n",
       "          0.35226282, -0.50233531, -0.90180375,  0.73535787,  0.56509058],\n",
       "        [-0.82453141, -0.07757142, -0.40848273, -0.07197003, -0.05247721,\n",
       "          0.13227664,  0.59453522, -0.7115031 ,  0.693443  ,  0.2809882 ,\n",
       "          0.77522596, -0.85107386, -0.55534477,  0.80635448, -0.88174527,\n",
       "         -0.92619133,  0.64621776,  0.05111648, -0.17886399,  0.84900515]]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.uniform(low=-1.0, high=1.0, size=(1_000, 100))\n",
    "type(data[0, 0]), data[:2, :20]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you can create an index for your vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[990, 991, 992, 993, 994, 995, 996, 997, 998, 999]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = list(range(len(data)))\n",
    "index[-10:]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once a collection has been created, you can fill it in with `client.upsert()`. You need to provide the collection's name and the appropriate uploading process from our `models` module, in this case, [`Batch`](https://qdrant.tech/documentation/points/#upload-points).\n",
    "\n",
    "**Note:** Qdrant can only take in native Python iterables like lists and tuples. This is why you will notice the `.tolist()` method attached to our `data` matrix below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UpdateResult(operation_id=0, status=<UpdateStatus.COMPLETED: 'completed'>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.upsert(\n",
    "    collection_name=my_collection,\n",
    "    points=models.Batch(\n",
    "        ids=index,\n",
    "        vectors=data.tolist()\n",
    "    )\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can retrieve specific points based on their ID (for example, song X with ID 100) and get some additional information from that result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Record(id=100, payload={}, vector=[-0.10599836, 0.11068635, 0.04444738, -0.027097967, -0.09290919, -0.08676028, 0.06970812, -0.10418644, -0.072337456, -0.14927788, -0.11333238, 0.06487068, 0.015204664, 0.0020790289, -0.059932653, -0.01583718, 0.024277804, -0.17515527, 0.008782358, 0.063005924, 0.14756365, -0.10434394, 0.083360724, -0.14625706, -0.15841727, 0.1357714, -0.0031317412, 0.11139833, -0.042295743, -0.15759756, -0.056121986, -0.14682493, -0.1764052, 0.17180207, -0.14315128, -0.0013021046, -0.01968442, 0.04458566, -0.06287631, 0.17405103, 0.14192675, -0.057540677, 0.026332472, 0.16844778, -0.047596026, -0.0472639, -0.11070978, 0.049258128, 0.03533134, 0.15809262, 0.035617046, 0.106708094, -0.13444023, 0.117557324, 0.1672869, 0.016368773, -0.0333911, 0.10456425, 0.104310416, -0.08187919, 0.070905924, 0.13841578, -0.019744948, -0.16601983, -0.019578911, 0.042030502, 0.036291942, -0.13290662, -0.14383806, 0.029476542, 0.1535214, -0.12118013, -0.1076026, -0.045408934, -0.03006504, -0.03663878, 0.056646116, -0.12882571, -0.093795806, 0.009991121, 0.03645561, -0.020317417, 0.0906876, -0.040670637, -0.0884878, -0.10439095, -0.08283463, 0.15414381, 0.08472449, 0.13265991, -0.023909355, 0.124651045, 0.16598777, 0.106182486, -0.09869526, -0.06457695, -0.16313535, 0.0076360404, -0.11167924, 0.011846884], shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.retrieve(\n",
    "    collection_name=my_collection,\n",
    "    ids=[100],\n",
    "    with_vectors=True # the default is False\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also update the collection one point at a time; e.g. as new data is coming in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_song():\n",
    "    return np.random.uniform(low=-1.0, high=1.0, size=100).tolist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UpdateResult(operation_id=1, status=<UpdateStatus.COMPLETED: 'completed'>)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.upsert(\n",
    "    collection_name=my_collection,\n",
    "    points=[\n",
    "        models.PointStruct(\n",
    "            id=1000,\n",
    "            vector=create_song(),\n",
    "        )\n",
    "    ]\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also delete a point in a straightforward fashion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountResult(count=1001)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this will show the amount of vectors BEFORE deleting the one we just created\n",
    "client.count(\n",
    "    collection_name=my_collection, \n",
    "    exact=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UpdateResult(operation_id=2, status=<UpdateStatus.COMPLETED: 'completed'>)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.delete(\n",
    "    collection_name=my_collection,\n",
    "    points_selector=models.PointIdsList(\n",
    "        points=[1000],\n",
    "    ),\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountResult(count=1000)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this will show the amount of vectors AFTER deleting them\n",
    "client.count(\n",
    "    collection_name=my_collection, \n",
    "    exact=True,\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 Payloads"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With Qdrant you can store additional information alongside vectors. This is called a [payload](https://qdrant.tech/documentation/payload/) and it is represented as JSON objects. With these payloads, not only can you retrieve information when you search the database, but you can also filter your search by the parameters in the payload, and we'll see how in a second.\n",
    "\n",
    "Following the narrative that our dummy vectors \"represent a song,\" in a semantic search system for this kind of data, you would want to retrieve the song file, its URL, the artist or the genre, among others.\n",
    "\n",
    "We will take advantage of a Python package called `faker` and create a bit of fake information to add to our payload to test this functionality."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from faker import Faker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Alex Yoder'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fake_something = Faker()\n",
    "fake_something.name()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For each vector, you can create list of dictionaries containing the artist's name, the song, a url to the song, the year in which it was released, and the country where it originated from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'artist': 'Brandy Thomas',\n",
       "  'song': 'amount painting result',\n",
       "  'url_song': 'https://morales.info/',\n",
       "  'year': '1985',\n",
       "  'country': 'Croatia'},\n",
       " {'artist': 'Dr. Lisa Flynn',\n",
       "  'song': 'thing admit cultural',\n",
       "  'url_song': 'http://garza.com/',\n",
       "  'year': '1973',\n",
       "  'country': 'Australia'},\n",
       " {'artist': 'Eric Lee',\n",
       "  'song': 'yeah argue throughout',\n",
       "  'url_song': 'http://roberts-cruz.net/',\n",
       "  'year': '2022',\n",
       "  'country': 'Gambia'}]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "payload = []\n",
    "\n",
    "for i in range(len(data)):\n",
    "    payload.append(\n",
    "        {\n",
    "            \"artist\":   fake_something.name(),\n",
    "            \"song\":     \" \".join(fake_something.words()),\n",
    "            \"url_song\": fake_something.url(),\n",
    "            \"year\":     fake_something.year(),\n",
    "            \"country\":  fake_something.country()\n",
    "        }\n",
    "    )\n",
    "\n",
    "payload[:3]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can upsert your Points (ids, data, and payload), with the same `client.upsert()` method you used earlier. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "UpdateResult(operation_id=3, status=<UpdateStatus.COMPLETED: 'completed'>)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.upsert(\n",
    "    collection_name=my_collection,\n",
    "    points=models.Batch(\n",
    "        ids=index,\n",
    "        vectors=data.tolist(),\n",
    "        payloads=payload\n",
    "    )\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to retrieve this info, use the `client.retrieve()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(list,\n",
       " [Record(id=10, payload={'artist': 'Elizabeth White', 'country': 'Madagascar', 'song': 'rock idea option', 'url_song': 'https://johnson-young.com/', 'year': '2009'}, vector=None, shard_key=None, order_value=None),\n",
       "  Record(id=50, payload={'artist': 'Alex Noble', 'country': 'Monaco', 'song': 'spend result air', 'url_song': 'http://www.becker.com/', 'year': '2017'}, vector=None, shard_key=None, order_value=None),\n",
       "  Record(id=100, payload={'artist': 'Jimmy Martinez', 'country': 'Qatar', 'song': 'bag they itself', 'url_song': 'https://www.bishop.com/', 'year': '2006'}, vector=None, shard_key=None, order_value=None),\n",
       "  Record(id=500, payload={'artist': 'David Wilson', 'country': 'Argentina', 'song': 'same soon service', 'url_song': 'http://matthews.org/', 'year': '2002'}, vector=None, shard_key=None, order_value=None)])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resutls = client.retrieve(\n",
    "    collection_name=my_collection,\n",
    "    ids=[10, 50, 100, 500],\n",
    "    with_vectors=False\n",
    ")\n",
    "\n",
    "type(resutls), resutls"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The response is a list with records and each element inside a record can be accessed as an attribute, e.g. `.payload` or `.id`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'artist': 'Elizabeth White',\n",
       " 'country': 'Madagascar',\n",
       " 'song': 'rock idea option',\n",
       " 'url_song': 'https://johnson-young.com/',\n",
       " 'year': '2009'}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resutls[0].payload"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "resutls[0].id"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, you will use the payload to conduct a search query."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.3 Search"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have your vectors with an ID and a payload, you can start searching for content when new music gets selected. \n",
    "\n",
    "Assume that a new song (like [\"living la vida loca\"](https://www.youtube.com/watch?v=p47fEXGabaY&ab_channel=RickyMartinVEVO) by Ricky Martin) comes in and our model immediately transforms it into a vector. Since we don't want a large amount of values back, let's limit the search to a few points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "living_la_vida_loca = create_song()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=874, version=3, score=0.33814278, payload={'artist': 'Yolanda Rosario', 'country': 'Puerto Rico', 'song': 'without source watch', 'url_song': 'https://li.com/', 'year': '1972'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=532, version=3, score=0.31217313, payload={'artist': 'Tamara Fowler', 'country': 'Yemen', 'song': 'security very since', 'url_song': 'https://www.jimenez-perkins.com/', 'year': '1987'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=437, version=3, score=0.3039009, payload={'artist': 'Jeffrey Wilson', 'country': 'Bangladesh', 'song': 'example bag where', 'url_song': 'https://larson.com/', 'year': '1989'}, vector=None, shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.query_points(\n",
    "    collection_name=my_collection,\n",
    "    query=living_la_vida_loca,\n",
    "    limit=3\n",
    ").points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume you only want Australian songs recommended to you. For this, you can filter the query using the information in the payload. You have to first create a filter object and then pass it to the search method as an argument to the parameter `query_filter=`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "qdrant_client.http.models.models.Filter"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aussie_songs = models.Filter(\n",
    "    must=[models.FieldCondition(key=\"country\", match=models.MatchValue(value=\"Australia\"))]\n",
    ")\n",
    "type(aussie_songs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=101, version=3, score=0.09454475, payload={'artist': 'Lindsay Johnson', 'country': 'Australia', 'song': 'program television tax', 'url_song': 'http://www.wright.com/', 'year': '1985'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=1, version=3, score=0.029051725, payload={'artist': 'Dr. Lisa Flynn', 'country': 'Australia', 'song': 'thing admit cultural', 'url_song': 'http://garza.com/', 'year': '1973'}, vector=None, shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.query_points(\n",
    "    collection_name=my_collection,\n",
    "    query=living_la_vida_loca,\n",
    "    query_filter=aussie_songs,\n",
    "    limit=2\n",
    ").points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, assume we want aussie songs but we don't care how new or old these songs are. Exclude the year from the payload."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=101, version=3, score=0.09454475, payload={'artist': 'Lindsay Johnson', 'country': 'Australia', 'song': 'program television tax', 'url_song': 'http://www.wright.com/'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=1, version=3, score=0.029051725, payload={'artist': 'Dr. Lisa Flynn', 'country': 'Australia', 'song': 'thing admit cultural', 'url_song': 'http://garza.com/'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=222, version=3, score=-0.06252488, payload={'artist': 'Laura Maldonado', 'country': 'Australia', 'song': 'despite sea far', 'url_song': 'https://clark.com/'}, vector=None, shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.query_points(\n",
    "    collection_name=my_collection,\n",
    "    query=living_la_vida_loca,\n",
    "    query_filter=aussie_songs,\n",
    "    with_payload=models.PayloadSelectorExclude(exclude=[\"year\"]),\n",
    "    limit=5\n",
    ").points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, you can apply a wide-range of filtering methods to allows your users to take more control of the recommendations they are being served.\n",
    "\n",
    "If you wanted to clear out the payload and upload a new one for the same vectors, you can use `client.clear_payload()` as below.\n",
    "\n",
    "```python\n",
    "client.clear_payload(\n",
    "    collection_name=my_collection,\n",
    "    points_selector=models.PointIdsList(\n",
    "        points=index,\n",
    "    )\n",
    ")\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Recommendation systems"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A recommendation system is a technology that suggests items or content to users based on their preferences, interests, or past behavior. In its most widely-used form, recommendation systems work by analyzing data about you and other users. The system looks at your previous choices, such as movies you've watched, products you've bought, or articles you've read. It then compares this information with data from other people who have similar tastes or interests. \n",
    "\n",
    "Such systems are used in various companies such as Netflix, Amazon, Tik-Tok, and Spotify. They aim to personalize your experience, save you time searching for things you might like, or introduce you to new and relevant content that you may not have discovered otherwise.\n",
    "\n",
    "Qdrant's API supports such a system, letting you account for user feedback. For example, you can recommend songs based on user likes (👍) or exclude similar ones to content users have disliked (👎).\n",
    "\n",
    "To do this, use the `client.recommend()` method and consider the following elements:\n",
    "\n",
    "- `collection_name=` - the collection from which the vectors are selected\n",
    "- `query_filter=` - optional filter to apply to your search\n",
    "- `negative=` - optionally, specify the `id` of disliked songs to exclude other semantically similar songs\n",
    "- `positive=` - in case of liked songs, specify their `id` to exclude similar songs (required)\n",
    "- `limit=` - specifies how many songs to show to the user\n",
    "\n",
    "Imagine there are two songs, \"[Suegra](https://www.youtube.com/watch?v=p7ff5EntWsE&ab_channel=RomeoSantosVEVO)\" by Romeo Santos and \"[Worst Behavior](https://www.youtube.com/watch?v=U5pzmGX8Ztg&ab_channel=DrakeVEVO)\" by Drake represented by the ids 17 and 120 respectively. Let's see what we would get with the former being a 👍 and the latter being a 👎."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=46, version=3, score=0.3310853, payload={'artist': 'Felicia Yang', 'country': 'Brunei Darussalam', 'song': 'pattern help within', 'url_song': 'http://www.gonzalez.biz/', 'year': '2006'}, vector=None),\n",
       " ScoredPoint(id=840, version=3, score=0.3030827, payload={'artist': 'Charles Brown', 'country': 'Somalia', 'song': 'network national very', 'url_song': 'https://www.larson-hartman.com/', 'year': '1975'}, vector=None),\n",
       " ScoredPoint(id=771, version=3, score=0.2851892, payload={'artist': 'Lori Clark', 'country': 'Myanmar', 'song': 'why box back', 'url_song': 'https://sanchez-waters.biz/', 'year': '1992'}, vector=None),\n",
       " ScoredPoint(id=304, version=3, score=0.28324583, payload={'artist': 'Steven Fitzgerald', 'country': 'Kyrgyz Republic', 'song': 'so suddenly indicate', 'url_song': 'http://www.stevens.com/', 'year': '1994'}, vector=None),\n",
       " ScoredPoint(id=544, version=3, score=0.26716217, payload={'artist': 'Christopher Bowman', 'country': 'Yemen', 'song': 'strategy late same', 'url_song': 'http://herrera.com/', 'year': '2012'}, vector=None)]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.recommend(\n",
    "    collection_name=my_collection,\n",
    "    positive=[17],\n",
    "    limit=5\n",
    ")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=756, version=3, score=0.31679478, payload={'artist': 'Chad Garza', 'country': 'Namibia', 'song': 'movie find method', 'url_song': 'http://www.moore.com/', 'year': '2018'}, vector=None),\n",
       " ScoredPoint(id=46, version=3, score=0.2964203, payload={'artist': 'Felicia Yang', 'country': 'Brunei Darussalam', 'song': 'pattern help within', 'url_song': 'http://www.gonzalez.biz/', 'year': '2006'}, vector=None),\n",
       " ScoredPoint(id=233, version=3, score=0.28002173, payload={'artist': 'Julie King', 'country': 'Congo', 'song': 'since really house', 'url_song': 'https://williams.com/', 'year': '1971'}, vector=None),\n",
       " ScoredPoint(id=349, version=3, score=0.25943768, payload={'artist': 'Geoffrey Wagner', 'country': 'Zimbabwe', 'song': 'station condition candidate', 'url_song': 'https://jackson.net/', 'year': '2015'}, vector=None),\n",
       " ScoredPoint(id=304, version=3, score=0.2552938, payload={'artist': 'Steven Fitzgerald', 'country': 'Kyrgyz Republic', 'song': 'so suddenly indicate', 'url_song': 'http://www.stevens.com/', 'year': '1994'}, vector=None)]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.recommend(\n",
    "    collection_name=my_collection,\n",
    "    query_vector=living_la_vida_loca,\n",
    "    positive=[17],\n",
    "    negative=[120],\n",
    "    limit=5\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that, while the similarity scores are completely random for this example, it is important to we pay attention to the scores retrieved when serving recommendations in production. Even if you get 5 vectors back, it might be more useful to show random results, rather than vectors that are 0.012 similar to the query vector. With this in mind, you can actually set a threshold for our vectors with the `score_threshold=` parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=67, version=3, score=0.32367542, payload={'artist': 'Thomas Burns', 'country': 'United Kingdom', 'song': 'at go class', 'url_song': 'https://www.wiley-morgan.com/', 'year': '1981'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=122, version=3, score=0.29786378, payload={'artist': 'Lori Meyer', 'country': 'Barbados', 'song': 'among contain strong', 'url_song': 'http://www.harris.org/', 'year': '2011'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=248, version=3, score=0.2886583, payload={'artist': 'Jacob Horn', 'country': 'Morocco', 'song': 'decide question able', 'url_song': 'http://www.miller-richmond.com/', 'year': '1994'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=956, version=3, score=0.28638673, payload={'artist': 'Amy Francis', 'country': 'Italy', 'song': 'whole beyond floor', 'url_song': 'https://www.williams.info/', 'year': '2019'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=984, version=3, score=0.2774799, payload={'artist': 'Evan Jordan', 'country': 'Nigeria', 'song': 'old raise glass', 'url_song': 'http://www.jenkins-nunez.biz/', 'year': '2005'}, vector=None, shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.query_points(\n",
    "    collection_name=my_collection,\n",
    "    query=models.RecommendQuery(recommend=models.RecommendInput(\n",
    "        positive=[17],\n",
    "        negative=[120, 180]\n",
    "    )),\n",
    "    score_threshold=0.22,\n",
    "    limit=5\n",
    ").points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, you can add filters in the same way as you did before. Note that these filters could be tags that your users get to pick such as, for example, genres including `reggeaton`, `bachata`, and `salsa` (sorry Drake), or the language of the song."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[ScoredPoint(id=81, version=3, score=0.037227698, payload={'artist': 'Danielle Acosta', 'country': 'Dominican Republic', 'song': 'fund stage last', 'url_song': 'http://pacheco.com/', 'year': '1974'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=833, version=3, score=0.031101033, payload={'artist': 'Vanessa Howard', 'country': 'Dominican Republic', 'song': 'report recently spring', 'url_song': 'http://rosario-romero.com/', 'year': '2019'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=787, version=3, score=-0.01613924, payload={'artist': 'John Lee', 'country': 'Dominican Republic', 'song': 'safe present so', 'url_song': 'https://church-cook.biz/', 'year': '2018'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=78, version=3, score=-0.09762458, payload={'artist': 'Mary Alvarado', 'country': 'Dominican Republic', 'song': 'great letter specific', 'url_song': 'http://cole.com/', 'year': '1986'}, vector=None, shard_key=None, order_value=None),\n",
       " ScoredPoint(id=332, version=3, score=-0.12651296, payload={'artist': 'Cheryl Garrett', 'country': 'Dominican Republic', 'song': 'drive design animal', 'url_song': 'https://kerr-davis.com/', 'year': '1971'}, vector=None, shard_key=None, order_value=None)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "client.query_points(\n",
    "    collection_name=my_collection,\n",
    "    query=models.RecommendQuery(recommend=models.RecommendInput(\n",
    "        positive=[17],\n",
    "        negative=[120, 180]\n",
    "    )),\n",
    "    query_filter=models.Filter(\n",
    "        must=[models.FieldCondition(key=\"country\", match=models.MatchValue(value=\"Dominican Republic\"))]\n",
    "    ),\n",
    "    limit=5\n",
    ").points"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it! You have now gone over a whirlwind tour of vector databases and are ready to tackle new challenges. 😎"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Conclusion"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To wrap up, we have explored a bit of the fascinating world of vector databases, and we learned that these databases provide efficient storage and retrieval of high-dimensional vectors, making them ideal for similarity-based search tasks and recommendation systems. Both of these use cases can be applied in a variety of industries while helping us unlock new levels of information retrieval. In particular, recommendation systems built with Qdrant provide developers with enough flexibility to add and subtract data points that users liked or disliked, respectively, and even set up a threshold for how similar a recommendation must be before our applications can serve it.\n",
    "\n",
    "We can't wait to see what cool applications you build with Qdrant.\n",
    "\n",
    "If you liked this introductory tutorial, make sure you keep an eye out for new ones on our website."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Resources"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a list with some resources that we found useful, and that helped with the development of this tutorial.\n",
    "\n",
    "- [Fine Tuning Similar Cars Search](https://qdrant.tech/articles/cars-recognition/)\n",
    "- [Q&A with Similarity Learning](https://qdrant.tech/articles/faq-question-answering/)\n",
    "- [Question Answering with LangChain and Qdrant without boilerplate](https://qdrant.tech/articles/langchain-integration/)\n",
    "- [Extending ChatGPT with a Qdrant-based knowledge base](https://qdrant.tech/articles/chatgpt-plugin/)\n",
    "- [Word Embedding and Word2Vec, Clearly Explained!!!](https://www.youtube.com/watch?v=viZrOnJclY0&ab_channel=StatQuestwithJoshStarmer) by StatQuest with Josh Starmer\n",
    "- [Word Embeddings, Bias in ML, Why You Don't Like Math, & Why AI Needs You](https://www.youtube.com/watch?v=25nC0n9ERq4&ab_channel=RachelThomas) by Rachel Thomas"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}