Log in Start Free
Start Free

EDGE VECTOR SEARCH

Run Vector Search On Device

Qdrant Edge is an embedded vector search engine that runs inside your application process, with no Docker, no background service, and an install footprint of around 11 MB.

Ship it on robots, kiosks, home assistants, and mobile phones, or anywhere connectivity is limited or intermittent, then sync with a central Qdrant server when you need to.

Get Started Read Documentation
Alert

Qdrant Edge is in beta as of August 2026. The API and functionality may change in future releases.

python

pip install qdrant-edge-py

from qdrant_edge import (
    Distance, EdgeConfig, EdgeShard,
    EdgeVectorParams, Query, QueryRequest,
)

config = EdgeConfig(
    vectors={"text": EdgeVectorParams(size=384, distance=Distance.Cosine)}
)
shard = EdgeShard.create("./edge", config)

results = shard.query(
    QueryRequest(
        query=Query.Nearest(query_vector, using="text"),
        limit=10,
    )
)

Why Use Qdrant Edge

Check Out Our Demo
01
WORKS OFFLINE

Built for limited or intermittent connectivity.

Search runs locally whether the link is up or down, and your application can queue writes for the server until it returns.

02
ULTRA-LOW LATENCY

No network round trip.

Qdrant Edge runs inside your application process, so a query reads straight from local disk.

03
DATA PRIVACY

Data stays on the device.

Nothing goes to an external server unless your application syncs it.

WHAT YOU GET

Search Locally,
Sync Centrally

Running on the device doesn't mean the device is on its own. Each Edge Shard is self-contained, manages its own vector and payload storage, and runs search locally. Sync it with a collection on a central Qdrant server.

Index

Build the index where the compute is.

Building an index takes more compute than an edge device has. Write your points to a Qdrant server as well as the local shard, let the server build the index, and sync back only the segments that changed.

Backup

Back up and restore a device.

Push a shard's data to a central Qdrant server, and restore it when a device is replaced, reset, or provisioned for the first time.

Analyze

Analyze across the whole fleet.

Pull data from Edge Shards across your fleet into one Qdrant server when you need to query or analyze across devices rather than within one.

Sync

Keep the fleet on the same data.

Synchronize Edge Shards through a central Qdrant server to keep every device working from the same set.

HOW TO GET STARTED

From Install To First Query

Hard drive

Create or load an Edge Shard on local disk.

Install the Python bindings with pip install qdrant-edge-py, or add the qdrant-edge crate for Rust. Call create to start a new shard at a path you choose, or load to open one that already has data.

App window

Update and query it directly from your application.

Write and query points in the same process, with no client to configure and no connection to open. Call flush to persist writes and optimize to compact the shard. Nothing runs between your calls.

Refresh

Synchronize with a central Qdrant server whenever you need to.

Apply a partial snapshot from the server with update_from_snapshot in Python, or recover_partial_snapshot in Rust.

Hard drive download

Install a library and open a file on disk. There is no container to build and nothing to run between your calls.

Read The Qdrant Edge Synchronization Guide

ON-DEVICE INFERENCE

Everything Runs On The Device

Dense, sparse, and multivector search, hybrid queries, and payload filtering run in your process on the device, with the same query primitives as Qdrant server.

Embed With FastEmbed

Generate vector embeddings directly on the device with FastEmbed, so both halves of a retrieval step run in the same process.

Read About On-Device Embeddings

Run Hybrid Search

Prefetch dense and BM25 sparse results inside the same shard and fuse them with Reciprocal Rank Fusion, in-process and offline.

On-Device BM25

Filter And Facet On Payload

Store payload next to your vectors, filter on it at query time, and keep live facet counts per class.

See It Running

python

from fastembed import ImageEmbedding, TextEmbedding

TEXT_MODEL_NAME='Qdrant/clip-ViT-B-32-text'
VISION_MODEL_NAME='Qdrant/clip-ViT-B-32-vision'
MODELS_DIR="./qdrant-edge-directory/models"

ImageEmbedding(
    model_name=VISION_MODEL_NAME,
    cache_dir=MODELS_DIR
)

TextEmbedding(
    model_name=TEXT_MODEL_NAME,
    cache_dir=MODELS_DIR
)

python

from qdrant_edge import (
    EdgeConfig,
    EdgeShard,
    EdgeSparseVectorParams,
    Modifier,
)

config = EdgeConfig(
    sparse_vectors={"text": 
EdgeSparseVectorParams(modifier=Modifier.Idf)}
,
)

shard = EdgeShard.create(SHARD_DIRECTORY, config)
Demo

HARDWARE FIT

Built For Constrained Devices

from pathlib import Path

SHARD_DIRECTORY = "./qdrant-edge-directory"

Path(SHARD_DIRECTORY).mkdir(parents=True, exist_ok=True)


const SHARD_DIRECTORY: &str = "./qdrant-edge-directory";

fs_err::create_dir_all(SHARD_DIRECTORY)?;

Runs on devices with no room for a database process.

Qdrant Edge uses CPU and memory only while your application is calling it, so it isn't taking resources from the model running alongside it.

Each device carries its own shard.

An Edge Shard is self-contained and operates independently, so adding a device means creating another shard rather than scaling a cluster.

Python and Rust today.

Qdrant Edge ships Python bindings on PyPI and the qdrant-edge crate on crates.io. If your application uses another language, talk to us before you commit to an architecture.

Read The Qdrant Edge Quickstart

FAQs

How is Qdrant Edge different from running Qdrant on a small machine?
Qdrant Server uses a client-server architecture: you run it as a process and talk to it over the network. Qdrant Edge runs inside your application process instead, as an embedded library with no background services. Think of it as SQLite, but for vector search. There's no server to deploy, no port to expose, and no network hop between your application and its data.
How does synchronization with a central Qdrant server work?
Qdrant Edge provides APIs to synchronize an Edge Shard with a Qdrant server collection. Apply a partial snapshot to the shard with update_from_snapshot in Python or recover_partial_snapshot in Rust. You can use this to offload indexing to a more powerful instance, back up and restore data, aggregate data from multiple devices centrally, or keep devices consistent with each other.
Which languages does Qdrant Edge support?
Python and Rust. Install the Python bindings with pip install qdrant-edge-py, or add the qdrant-edge crate. Examples for both are in the Qdrant GitHub repository. If you need another language, talk to us before committing to an architecture.
Can I generate embeddings on the device?
Yes. Generate vector embeddings on-device with FastEmbed, and BM25 sparse embeddings on-device for keyword search. Both have their own guides in the Qdrant Edge documentation.
Is Qdrant Edge ready for production?
Qdrant Edge is in beta as of August 2026, and the API and functionality may change in future releases. It's publicly available and you can start building with it today. Talk to us about your device class and timeline if you need stability guarantees.
Which Qdrant features does Qdrant Edge support?
Qdrant Edge supports dense, sparse, and multivector search, named vectors, hybrid search, quantization, HNSW indexing, and payload indexes on all field types. It differs from Qdrant server in operations: you run optimization and indexing yourself, and there's no replication or distributed mode. See Edge vs. Qdrant Cluster for the full comparison.
What can an Edge Shard do?
An Edge Shard manages its own vector and payload storage and performs search and retrieval locally. The API covers creating and loading a shard, updating and querying data, faceting, scrolling, counting, retrieving by ID, flushing to disk, optimizing, reading shard metadata, and applying snapshots.

Start Building On Qdrant Edge

Install the bindings, create a shard on local disk, and query it in the same process. Provision a Qdrant Cloud cluster when you want a central collection to synchronize with.

pip install qdrant-edge-py Read the Quickstart
Rocket flying over globe illustration