Getting Started with Qdrant

Welcome to the first lesson of the course, "Storing, Indexing, and Managing Vector Data with Qdrant." In this lesson, we will explore Qdrant, an open-source vector database designed to efficiently handle vector data. Vector data is crucial for applications like semantic search, where understanding the meaning behind data is essential. Our goal in this lesson is to guide you through the process of setting up and initializing Qdrant, and creating or connecting to a collection. This foundational step will prepare you for more advanced operations in subsequent lessons.

Before we dive into using Qdrant, it's important to set up your environment. Qdrant provides a Python client library, which you can install using pip. On your local machine, pin a tested client version, such as pip install "qdrant-client==1.12.1", to reduce the risk of API changes affecting your code. Also pin the Qdrant server/container version, such as qdrant/qdrant:v1.12.1, to keep client and server APIs compatible. In the CodeSignal environment, compatible Qdrant components are pre-installed, so you can focus on learning without worrying about installation.

In this course, we are going to use a local Qdrant instance, which is running as a Docker container and is already connected to our IDE. This allows you to develop and practice without needing an API key or cloud account. Please note:

• Qdrant is an open-source vector database that persists data to disk by default.
• There is no built-in 100,000 point per collection limit in Qdrant itself; any such limits in this course are specific to the lab environment and are not a property of Qdrant.
• By default, Qdrant does not require authentication for local development, but authentication can be configured for production deployments.

Now, let's set up the Qdrant client for local development. To interact with your local Qdrant instance, you need to create a client and specify the host and port where Qdrant is running. This setup does not require an API key, making it straightforward for local experimentation:

from qdrant_client import QdrantClient

# Initialize a client.
# Host and port of the local Qdrant instance is required.
client = QdrantClient(
    host="localhost",
    port=6333
)

The code above creates a QdrantClient object that connects to your local Qdrant server. With this client, you can now perform operations such as creating collections, inserting vectors, and running queries.

A collection in Qdrant is a data structure that allows you to store and search vector data efficiently. It is similar to a table in a traditional database. To create or connect to a collection, you need to specify parameters such as the collection name, vector size, and distance metric. Here's an example of how to create or connect to a collection using the recommended collection_exists and create_collection methods:

A compact way to visualize the Qdrant data model is:

Collection
└── Point
    ├── id
    ├── vector
    └── payload metadata

collection_name = "vector-collection"

# Check if the collection exists using collection_exists
if not client.collection_exists(collection_name=collection_name):
    client.create_collection(
        collection_name=collection_name,
        vectors_config={
            "size": 384,
            "distance": "Cosine"
        }
    )
    print(f"Created new collection: {collection_name}")
else:
    print(f"Collection '{collection_name}' already exists.")

print(f"Qdrant initialized with collection: {collection_name}")

In this example, we first check if the collection named vector-collection already exists by using the collection_exists method. If it does not exist, we create it using create_collection(), specifying several parameters:

• collection_name: The name of the collection.
• vectors_config: A dictionary specifying the size of the vectors you will store and the distance metric to use for similarity search.

This approach follows the latest best practices and avoids deprecated methods.

Let's walk through the complete code example to ensure you understand each part of the process. First, we import the necessary module and initialize the Qdrant client for local development. This step sets up the client to interact with the local Qdrant instance.

Next, we create or connect to a collection named vector-collection. This collection will store our vector data, allowing us to perform operations like inserting, querying, and managing vectors. Here's the complete code:

from qdrant_client import QdrantClient

# Initialize a client.
client = QdrantClient(
    host="localhost",
    port=6333
)

collection_name = "vector-collection"

# Check if the collection exists using collection_exists
if not client.collection_exists(collection_name=collection_name):
    client.create_collection(
        collection_name=collection_name,
        vectors_config={
            "size": 384,
            "distance": "Cosine"
        }
    )
    print(f"Created new collection: {collection_name}")
else:
    print(f"Collection '{collection_name}' already exists.")

print(f"Qdrant initialized with collection: {collection_name}")

# Delete collection when you no longer need it
client.delete_collection(collection_name)

When you run this code, you should see the output: "Qdrant initialized with collection: vector-collection." This confirms that the client is set up and the collection is ready for use. If you encounter any errors, ensure that the qdrant-client module is installed and that the local Qdrant instance is running. Additionally, the code includes a step to delete the collection when it is no longer needed, demonstrating how to manage the lifecycle of a collection.

In this lesson, we introduced Qdrant and its role in managing vector data. You learned how to set up your environment, initialize a Qdrant client, and create or connect to a collection. These foundational steps are crucial for working with vector data in Qdrant. As you move forward, you'll have the opportunity to practice these concepts through exercises that reinforce what you've learned. In the next lessons, we'll delve deeper into inserting and storing embeddings, querying data, and optimizing search performance.