How to Run the Qdrant Vector Database in a Cloud Sandbox

sbx new --name qdrant --type small --no-env
id=sb_3hog0mh29o    # the id that sbx new printed

sbx exec $id --timeout 600 'openssl rand -hex 24 > ~/qdrant.key && chmod 600 ~/qdrant.key && \
  docker run -d --name qdrant --restart unless-stopped \
    -p 127.0.0.1:6333:6333 -v qdrant_storage:/qdrant/storage \
    -e QDRANT__SERVICE__API_KEY=$(cat ~/qdrant.key) qdrant/qdrant:v1.20.0 && \
  until curl -sf http://127.0.0.1:6333/readyz >/dev/null; do sleep 0.3; done'
sbx exec $id 'curl -s http://127.0.0.1:6333/readyz; echo
curl -s -o /dev/null -w "no key: %{http_code}\n" http://127.0.0.1:6333/collections
curl -s -H "api-key: $(cat ~/qdrant.key)" http://127.0.0.1:6333/'

all shards are ready
no key: 401
{"title":"qdrant - vector search engine","version":"1.20.0","commit":"222b2e44ab1c3f17e8246396ead6558e45041df7"}

sbx exec $id --timeout 300 'bash -lc "uv venv -q .venv && uv pip install -q --python .venv/bin/python qdrant-client==1.20.0 numpy"'

import pathlib, statistics, time
import numpy as np
from qdrant_client import QdrantClient, models

key = pathlib.Path.home().joinpath("qdrant.key").read_text().strip()
client = QdrantClient(url="http://127.0.0.1:6333", api_key=key, https=False)
print("server", client.info().version)

N, DIM = 20_000, 384
rng = np.random.default_rng(7)
vectors = rng.random((N, DIM), dtype=np.float32)
categories = ["books", "music", "games", "tools", "garden"]

if client.collection_exists("products"):
    client.delete_collection("products")
client.create_collection(
    "products",
    vectors_config=models.VectorParams(size=DIM, distance=models.Distance.COSINE),
)
client.create_payload_index("products", "category", models.PayloadSchemaType.KEYWORD)

t0 = time.perf_counter()
for start in range(0, N, 1000):
    client.upsert(
        "products",
        points=models.Batch(
            ids=list(range(start, start + 1000)),
            vectors=vectors[start:start + 1000].tolist(),
            payloads=[{"category": categories[i % 5], "price": int(i % 100)} for i in range(start, start + 1000)],
        ),
        wait=True,
    )
print(f"upsert {N} points: {time.perf_counter() - t0:.1f} s")

t0 = time.perf_counter()
while True:
    info = client.get_collection("products")
    if info.status == models.CollectionStatus.GREEN:
        break
    time.sleep(0.2)
print(f"index ready after {time.perf_counter() - t0:.1f} s: status={info.status.value} points={info.points_count} indexed={info.indexed_vectors_count}")

flt = models.Filter(must=[
    models.FieldCondition(key="category", match=models.MatchValue(value="books")),
    models.FieldCondition(key="price", range=models.Range(lt=20)),
])
q = vectors[42].tolist()

def timed(**kw):
    times = []
    for _ in range(30):
        t = time.perf_counter()
        res = client.query_points("products", query=q, limit=10, **kw).points
        times.append((time.perf_counter() - t) * 1000)
    return res, statistics.median(times)

hits, ms = timed()
print(f"top-10, no filter: median {ms:.1f} ms; first hit id={hits[0].id} score={hits[0].score:.4f}")
hits, ms = timed(query_filter=flt)
print(f"top-10, category=books and price<20: median {ms:.1f} ms")
for h in hits[:3]:
    print(" ", h.id, round(h.score, 4), h.payload)
exact, _ = timed(query_filter=flt, search_params=models.SearchParams(exact=True))
print("overlap with exact search:", len({h.id for h in hits} & {h.id for h in exact}), "of 10")

sbx scp ./load.py $id:/home/user/
sbx exec $id --timeout 300 '.venv/bin/python -u load.py'

server 1.20.0
upsert 20000 points: 2.0 s
index ready after 2.5 s: status=green points=20000 indexed=14000
top-10, no filter: median 2.8 ms; first hit id=17341 score=0.7925
top-10, category=books and price<20: median 4.1 ms
  7705 0.7838 {'category': 'books', 'price': 5}
  9805 0.7776 {'category': 'books', 'price': 5}
  2005 0.7774 {'category': 'books', 'price': 5}
overlap with exact search: 10 of 10

import pathlib
from qdrant_client import QdrantClient, models
c = QdrantClient(url="http://127.0.0.1:6333", api_key=pathlib.Path.home().joinpath("qdrant.key").read_text().strip(), https=False)
q = c.retrieve("products", ids=[42], with_vectors=True)[0].vector
for label, params in [("hnsw ef=default", None), ("hnsw ef=256", models.SearchParams(hnsw_ef=256)), ("exact", models.SearchParams(exact=True))]:
    ids = [p.id for p in c.query_points("products", query=q, limit=10, search_params=params).points]
    print(f"{label:16} first={ids[0]} contains 42: {42 in ids}")
    if label == "exact": exact = set(ids)
    else: globals()[label] = set(ids)
print("default overlap with exact:", len(globals()["hnsw ef=default"] & exact), "of 10; ef=256:", len(globals()["hnsw ef=256"] & exact), "of 10")

hnsw ef=default  first=17341 contains 42: False
hnsw ef=256      first=42 contains 42: True
exact            first=42 contains 42: True
default overlap with exact: 6 of 10; ef=256: 10 of 10

sbx host $id 6333 --localhost --title Qdrant

https://lively-global-kestrel-6333.box.sandboxer.com?_token=<token>

# QDRANT_URL_WITH_TOKEN=<private hosted URL> QDRANT_API_KEY=<key> python remote.py
import os, statistics, time
from urllib.parse import urlsplit
import httpx
from qdrant_client import QdrantClient, models

link = os.environ["QDRANT_URL_WITH_TOKEN"]
r = httpx.get(link, follow_redirects=False)            # trade the token for the cookie
cookie = r.headers["set-cookie"].split(";")[0]
base = "https://" + urlsplit(link).hostname

client = QdrantClient(url=base, port=443, api_key=os.environ["QDRANT_API_KEY"],
                      headers={"Cookie": cookie}, timeout=10)
print("server", client.info().version)
print("points", client.count("products").count)

q = client.retrieve("products", ids=[42], with_vectors=True)[0].vector
flt = models.Filter(must=[models.FieldCondition(key="category", match=models.MatchValue(value="books"))])
times = []
for _ in range(20):
    t = time.perf_counter()
    hits = client.query_points("products", query=q, query_filter=flt, limit=5).points
    times.append((time.perf_counter() - t) * 1000)
print([(h.id, round(h.score, 4)) for h in hits])
print(f"median {statistics.median(times):.0f} ms, min {min(times):.0f} ms over {len(times)} queries")

server 1.20.0
points 20000
[(7705, 0.7838), (18855, 0.7832), (3375, 0.7825), (9295, 0.7812), (14485, 0.7809)]
median 128 ms, min 128 ms over 20 queries