Qdrant

Overview

Qdrant is an open-source vector similarity search engine and vector database that provides infrastructure for AI applications requiring efficient retrieval of high-dimensional vectors. Founded in 2021, Qdrant is built for scenarios such as semantic search, where user queries are matched against a database of document embeddings, and recommendation systems, which identify similar items based on user preferences or item characteristics Qdrant Use Cases. Its architecture is designed to handle large datasets of vectors, enabling real-time approximate nearest neighbor (ANN) search. This capability is foundational for many generative AI applications, including Retrieval Augmented Generation (RAG) patterns, where relevant context is fetched from a knowledge base to inform large language models RAG with Qdrant.

Qdrant offers flexible deployment options, including a self-hosted open-source version, a managed Qdrant Cloud service, and a Qdrant Hybrid solution for private cloud or on-premises deployments. The platform supports various distance metrics for vector comparison, such as cosine similarity, dot product, and Euclidean distance, which are crucial for accurately measuring the relatedness of vector embeddings Qdrant Distance Metrics. Beyond raw vector search, Qdrant allows for payload filtering alongside vector queries, meaning users can apply conditions to metadata associated with vectors to refine search results. This is particularly useful for faceted search or filtering recommendations based on specific attributes like category, price range, or publication date.

Developers interact with Qdrant through a well-documented HTTP API and gRPC interface, supported by client SDKs in Python, Go, Rust, TypeScript, and Java. The developer experience is streamlined with straightforward local Docker-based setup for development and testing environments Qdrant Installation Guide. For production environments, Qdrant provides features like data snapshotting, replication, and clustering to ensure high availability and fault tolerance. Its compliance certifications, including SOC 2 Type II, GDPR, and ISO 27001, address enterprise requirements for data security and privacy Qdrant Cloud Security.

Key features

• Vector Indexing and Storage: Efficiently stores and indexes high-dimensional vectors for fast retrieval.
• Approximate Nearest Neighbor (ANN) Search: Implements algorithms like HNSW (Hierarchical Navigable Small Worlds) for fast similarity search across large datasets Qdrant HNSW Indexing.
• Payload Filtering: Allows filtering search results based on metadata associated with vectors, supporting complex queries and faceted search.
• Multiple Distance Metrics: Supports cosine similarity, dot product, and Euclidean distance for flexible similarity calculations.
• Scalability and Clustering: Designed for horizontal scalability with distributed clusters to handle growing data volumes and query loads Qdrant Distributed Deployment.
• CRUD Operations: Provides comprehensive API endpoints for creating, reading, updating, and deleting vectors and their associated payloads.
• Snapshots and Backup: Enables creating and restoring snapshots of collection data for disaster recovery and data management.
• Developer-friendly APIs and SDKs: Offers HTTP API, gRPC interface, and client SDKs for Python, Go, Rust, TypeScript, and Java.
• Open Source and Cloud Options: Available as a self-hostable open-source project, a fully managed Qdrant Cloud service, and a hybrid deployment Qdrant Cloud.
• Data Resilience: Features like replication and write-ahead logs ensure data integrity and fault tolerance Qdrant Replication Factor.

Pricing

Qdrant Cloud offers a tiered pricing model based on compute units, storage for vectors and snapshots, and network egress. The open-source version is free to use and self-host. As of May 2026, the Qdrant Cloud pricing tiers are:

Detailed pricing calculations for compute units, vector storage, snapshot storage, and network egress are available on the Qdrant Cloud Pricing page.

Common integrations

• LangChain: Integration with Langchain allows Qdrant to serve as a vector store for RAG applications, facilitating the retrieval of relevant documents for large language models Qdrant LangChain Integration.
• LlamaIndex: Connects with LlamaIndex for advanced data indexing and query capabilities, enabling more sophisticated interactions with LLMs Qdrant LlamaIndex Integration.
• Hugging Face: Can be used with Hugging Face models to generate embeddings and then store them in Qdrant for similarity search Qdrant Semantic Search Tutorial.
• OpenAI: Integrates with OpenAI's embedding models to convert text into vectors for storage and search in Qdrant Qdrant OpenAI Integration.
• Docker: Qdrant can be easily deployed locally using Docker containers for development and testing environments Qdrant Docker Installation.
• Kubernetes: Supports deployment on Kubernetes for scalable and resilient cluster management in production environments Qdrant Kubernetes Guide.

Alternatives

• Pinecone: A fully managed vector database service focused on enterprise-grade performance and scalability.
• Weaviate: An open-source vector database that also functions as a vector search engine, offering a GraphQL API and support for various data types.
• Milvus: An open-source vector database built for AI applications, supporting billions of vector embeddings with high query performance.

Getting started

To get started with Qdrant, you can run it locally using Docker and interact with it via the Python client. This example demonstrates how to create a collection, insert some vectors, and perform a similarity search.

from qdrant_client import QdrantClient, models

# Initialize Qdrant client
# For local Docker instance, default port is 6333
client = QdrantClient(host="localhost", port=6333)

# Define collection name
collection_name = "my_vector_collection"

# Create a collection with a specific vector size and distance metric
# Vector size should match the dimensionality of your embeddings
client.recreate_collection(
    collection_name=collection_name,
    vectors_config=models.VectorParams(size=4, distance=models.Distance.COSINE),
)

# Define some data (vectors and optional payloads)
points_to_insert = [
    models.PointStruct(id=1, vector=[0.05, 0.61, 0.76, 0.74], payload={"city": "London", "country": "UK"}),
    models.PointStruct(id=2, vector=[0.19, 0.81, 0.75, 0.11], payload={"city": "Berlin", "country": "Germany"}),
    models.PointStruct(id=3, vector=[0.36, 0.55, 0.47, 0.94], payload={"city": "Paris", "country": "France"}),
    models.PointStruct(id=4, vector=[0.18, 0.01, 0.85, 0.80], payload={"city": "New York", "country": "USA"}),
    models.PointStruct(id=5, vector=[0.24, 0.63, 0.45, 0.35], payload={"city": "London", "country": "UK"})
]

# Upsert points (insert or update vectors and payloads)
client.upsert(
    collection_name=collection_name,
    wait=True,
    points=points_to_insert,
)

print(f"Upserted {len(points_to_insert)} points to collection: {collection_name}")

# Perform a similarity search for a query vector
query_vector = [0.2, 0.7, 0.6, 0.8]
search_result = client.search(
    collection_name=collection_name,
    query_vector=query_vector,
    limit=2, # Return top 2 results
    with_payload=True # Include payload in results
)

print("\nSearch results:")
for hit in search_result:
    print(f"Point ID: {hit.id}, Score: {hit.score:.4f}, Payload: {hit.payload}")

# You can also add filtering to your search
filtered_search_result = client.search(
    collection_name=collection_name,
    query_vector=query_vector,
    query_filter=models.Filter(
        must=[
            models.FieldCondition(
                key="country",
                range=models.FieldCondition.Range(eq="UK")
            )
        ]
    ),
    limit=1,
    with_payload=True
)

print("\nFiltered search results (country = UK):")
for hit in filtered_search_result:
    print(f"Point ID: {hit.id}, Score: {hit.score:.4f}, Payload: {hit.payload}")

To run this code, ensure you have the Qdrant client library installed (

pip install qdrant-client

docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant