Log in Start Free
Start Free

EDGE VECTOR SEARCH

Run Vector Search Where Your Data Lives

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.

pip install qdrant-edge-py Read Documentation
Alert

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

python

from pathlib import Path

SHARD_DIRECTORY = "./qdrant-edge-directory"

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

WHY EDGE VECTOR SEARCH

Three Reasons Teams Move Search Onto The Device

Check Our Demo
01
NO NETWORK
There's no network.

Qdrant Edge is built for limited or intermittent connectivity. Search locally whether the link is up or down, and queue writes until it returns.

02
LOW LATENCY
The answer can't wait for a round trip.

Qdrant Edge runs inside your application process. Search where your code and its data already sit.

03
DATA PRIVACY
The data never leaves the device.

Qdrant Edge stores and queries data 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.

Indexing is expensive, and an edge device is the wrong place to pay for it. 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 IT WORKS

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

Qdrant Edge keeps Qdrant's full retrieval surface. The same query primitives run in your process on the device as they do server-side.

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 is designed for in-process retrieval on devices that don't have room for a database process, and nothing runs between your calls.

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.
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