Exploring Qdrant Cloud and Vector Database

I recently came across Qdrant when doing some research in the RAG space, and decided to give it a try. Cloud trials, or docker images for local experimentation are so easy that it makes it almost comical to think about the old days of software trials.

First and foremost Qdrant is a Vector Database built for Semantic Search in modern (AI) systems. That makes it a natural fit for modern AI workloads like RAG pipelines, agent systems, and any scenario where meaning matters more than keywords.

When we finish the cluster creation we get a pair of API keys + Cluster Endpoint which we can use for connection.

Access Qdrant Cloud

pip install qdrant-client        

Then with these few code lines we can establish contact with the Cluster.

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, PointStruct, Document

# connect to Qdrant Cloud
client = QdrantClient(
    url="https://xyz-example.eu-central.aws.cloud.qdrant.io",
    api_key="your-api-key",
    cloud_inference=True
)

That’s it – we are connected

Collections is where vectors live

Qdrant organizes data into collections. A sort of spatial grouping where the closer a point is in space to another the similar they are.

First step will be adding a new data set, or collection. I did a similar exercise in a previous post where I had to process a Star Trek data file with generating embeddings, chunks and finally store that in a chromadb.

You can bring your own data or explore sample datasets.

I started with one of their CLIP based image datasets, where each image is represented as a vector (point) with optional metadata.

One cool thing is the 2D spacial visualization that allows to visually explore the data and the respective distances between 2 data points (in this case images).

When working with Oracle Digital Assistant (pre-Generative AI), we trained an NLP engine using custom data and had access to a 2D visualization that mapped utterances based on their relative distance and the grouping into intents. This made it easier to properly train the model, spot outliers, and identify which utterances needed further curation.

Qdrant SDK – Create Collection

Lets use the Python SDK to interact with the Qdrant Cluster. Most of the below code is from their own course – https://qdrant.tech/course/essentials/day-0/building-simple-vector-search/

I will use the default options for size and similarity model (COSINE) as there are many more and that discussion would be an entire post on itself.

 
# Define the collection name
collection_name = "StarTrek"

# Create the collection with specified vector parameters
client.create_collection(
    collection_name=collection_name,
    vectors_config=models.VectorParams(
        size=4,  # Dimensionality of the vectors
        distance=models.Distance.COSINE  # Distance metric for similarity search
    )
)

This gives us an empty collection, basically a ready to-use vector index.

Qdrant SDK – Insert Data

The next step feels a bit odd, but let’s just go with it. this is the code we can use to insert point data into the collection. What I am missing here is the conversion of data into the vector dimensions via a model. This should be the process of the embedding, but I guess we are focusing on the core steps for now.

points = [
    models.PointStruct(
        id=1,
        vector=[0.1, 0.2, 0.3, 0.4],  # 4D vector
        payload={"category": "deep space nine"}  # Metadata (optional)
    ),
    models.PointStruct(
        id=2,
        vector=[0.2, 0.3, 0.4, 0.5],
        payload={"category": "voyager"}
    )
]

# Insert vectors into the collection
client.upsert(
    collection_name=collection_name,
    points=points
)

This will add the data to the collection, and after that we will be able to run a similarity search

In a similar fashion as before, we ignore the full end to end process and respective query -> embedding -> search and go straight with a sample vector to try out the code

query_vector = [0.08, 0.14, 0.33, 0.28]

search_results = client.query_points(
    collection_name=collection_name,
    query=query_vector,
    limit=1  # Return the top 1 most similar vector
)

print("Search results:", search_results)

And this returns the closest vector to the one we provide as search parameter.

Search results: points=[ScoredPoint(id=1, version=2, score=0.97642946, payload={'category': 'deep space nine'}, vector=None, shard_key=None, order_value=None)]

Conclusion

So far the experience is clean and simple, all the necessary tools via UI and SDK are available and easy to use, but this was too simplistic of an exercise. The real power of these solutions comes when integrated on a broader architecture. RAG pipelines pulling from multiple data sources, spanning cloud and on-prem environments, all under real latency constraints and production pressure. Something to explore later…who knows 🙂