Qdrant

By Qdrant

High-performance open-source vector database for similarity search and agent memory

Website ↗ Repository ↗ Docs ↗

v1.18.32026-07-17RustApache-2.0

#vector-db #embeddings #rag #rust

33.5k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related tools

Sentence Transformers

Embedding Models

Overview

Qdrant is a fast, open-source vector database written in Rust, built for similarity search at scale.
It stores embeddings with JSON payloads and rich filtering, making it a common retrieval and long-term-memory layer for RAG and agents.

flowchart LR
  docs[documents] --> q[(Qdrant)]
  query[query] --> q
  q --> top[nearest points]

The Code samples tab shows the built-in embedder and a bring-your-own-vectors flow — pick from the selector to compare.

When to use it

Choose Qdrant when you want a dedicated vector store with strong performance and payload filtering — self-hosted with Docker or on Qdrant Cloud.

Pricing

Open source (Apache-2.0), free to self-host. Qdrant Cloud is resource-based.

Plan	Price	Notes
Free	$0	1GB cluster, permanent
Standard	~$30–200/mo	Resource-based clusters
Premium	Custom	HA, SSO, support

Source ↗ · as of 2026-06-27

Example

Python · add & query

When to use

Reach for the high-level client + fastembed when you want a vector store that embeds for you.

How it flows

add embeds and stores the documents; query embeds the query and returns nearest neighbours.

Structure

flowchart LR
  docs[documents] --> q[(Qdrant)]
  query[query] --> q
  q --> top[nearest points]

from qdrant_client import QdrantClient

client = QdrantClient(":memory:")  # in-memory; use url="http://localhost:6333"
# qdrant-client[fastembed] embeds the documents with a built-in model.
client.add("docs", documents=[
    "Cats are independent pets that purr.",
    "A rocket is propelled by ejecting exhaust.",
])

hits = client.query("docs", query_text="tell me about cats", limit=1)
print(hits[0].document)

When to use

Manage vectors yourself when an embedding model already produces them elsewhere in your pipeline.

How it flows

Create a collection with a distance metric, upsert points with payloads, then query by a vector for the nearest points.

Structure

flowchart LR
  vec[your vectors] --> coll[(collection)]
  q[query vector] --> coll
  coll --> top[top-k]

from qdrant_client import QdrantClient, models

client = QdrantClient(url="http://localhost:6333")
client.create_collection(
    "docs",
    vectors_config=models.VectorParams(size=4, distance=models.Distance.COSINE),
)
client.upsert("docs", points=[
    models.PointStruct(id=1, vector=[0.1, 0.2, 0.3, 0.4], payload={"text": "hello"}),
])

hits = client.query_points("docs", query=[0.1, 0.2, 0.3, 0.4], limit=1).points
print(hits[0].payload)

Example

Qdrant — vector similarity search (no server, no key)

A real, runnable mini-project. Download it and run with Docker.

View samples/qdrant_1 on GitHub ↗

June 28, 2026

Qdrant — vector similarity search (no server, no key)

A tiny Qdrant demo: it stores a few documents in an in-memory collection — fastembed embeds them locally — then runs a nearest-neighbour query. Swap the toy docs for your own and it is a RAG retriever. No API key.

Run with Docker

cd samples/qdrant_1
docker build -t aas-qdrant .
docker run --rm aas-qdrant "tell me about young cats"

The first run downloads a small fastembed model (BAAI/bge-small-en-v1.5, ~130 MB), so it needs internet once.

Run with Docker (in a devcontainer with DooD)

In a dev container that talks to the host Docker daemon (Docker-outside-of-Docker), the attached docker run may print nothing even though it ran — the live attached stream drops output over the VM boundary. Run detached and read the logs:

cd samples/qdrant_1
docker build -t aas-qdrant .
docker logs -f "$(docker run -d aas-qdrant "tell me about young cats")"

Run locally

cd samples/qdrant_1
pip install -r requirements.txt
python app.py "tell me about young cats"

Example run

Embeddings are deterministic (fixed model + input), so the ranking is the same every run — only the first run downloads the model.

nearest to 'tell me about young cats' by score:
  kitten     0.7082
  cat        0.6450
  airplane   0.4201

Files

app.py

"""Qdrant: vector similarity search with no server and no API key.

Stores a few documents in an in-memory Qdrant collection (fastembed embeds them
locally via `models.Document`), then runs a nearest-neighbour query. Swap the
toy docs for your own and it is a RAG retriever.

Run:
    docker build -t aas-qdrant .
    docker run --rm aas-qdrant "tell me about young cats"
"""

import sys

from qdrant_client import QdrantClient, models

MODEL = "BAAI/bge-small-en-v1.5"  # fastembed default, 384-dim

DOCS = {
    "cat": "Cats are independent pets that purr and chase laser pointers.",
    "kitten": "A kitten is a young cat that loves to play and nap.",
    "airplane": "An airplane is a powered flying vehicle with fixed wings.",
    "rocket": "A rocket is propelled by ejecting exhaust gas at high speed.",
}


def main() -> None:
    query = " ".join(sys.argv[1:]) or "tell me about young cats"

    client = QdrantClient(":memory:")  # in-memory; fastembed runs locally
    client.create_collection(
        "docs",
        vectors_config=models.VectorParams(size=384, distance=models.Distance.COSINE),
    )
    client.upsert(
        "docs",
        points=[
            models.PointStruct(
                id=i,
                vector=models.Document(text=text, model=MODEL),
                payload={"label": label},
            )
            for i, (label, text) in enumerate(DOCS.items())
        ],
    )

    hits = client.query_points(
        "docs",
        query=models.Document(text=query, model=MODEL),
        limit=3,
    ).points

    print(f"nearest to {query!r} by score:")
    for h in hits:
        print(f"  {h.payload['label']:10s} {h.score:.4f}")


if __name__ == "__main__":
    main()

Dockerfile

# Minimal image for the Qdrant sample. No API key — it runs an in-memory Qdrant
# and downloads a small fastembed model on first use.
FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENTRYPOINT ["python", "app.py"]