edge-mission-control
Edge Mission Control
If you build robots, their memory can't depend on the Wi-Fi, so Qdrant Edge recalls every object seen, offline.
- Products
- Solutions
- Developers
- Resources
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.
Qdrant Edge is in beta as of August 2026. The API and functionality may change in future releases.
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,
)
)
DEMOS
Same Qdrant, Device Or Cluster
The filters, hybrid queries and sync you run on a Qdrant server, running on robots, wearables, cameras and field hardware. Four applications on real footage: open one, search it, then read the code.
smart-glasses
Smart Glasses
Wearable makers need to search what the camera saw without footage leaving the device.
sentinel
Sentinel
Security teams can't watch every camera. Sentinel scores twelve feeds against normal and escalates the rest.
edge-visual-search
Edge Visual Search
If you run devices in the field, you need answers on site and the record at headquarters. Qdrant Edge syncs both.
Why Use Qdrant Edge
Check Out Our Demo01
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.
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.
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 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.
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
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.
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.
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.
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 EmbeddingsRun 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 BM25Filter 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 Runningfrom 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
)
from qdrant_edge import (
EdgeConfig,
EdgeShard,
EdgeSparseVectorParams,
Modifier,
)
config = EdgeConfig(
sparse_vectors={"text":
EdgeSparseVectorParams(modifier=Modifier.Idf)}
,
)
shard = EdgeShard.create(SHARD_DIRECTORY, config)
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.
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.
