id stringlengths 36 36 | url stringclasses 504
values | title stringclasses 475
values | section stringlengths 0 148 | content_type stringclasses 3
values | has_code bool 2
classes | text stringlengths 147 22.5k | vector listlengths 384 384 |
|---|---|---|---|---|---|---|---|
5f72a5b8-5cac-588d-ad60-5a61879880fc | /documentation/overview/what-is-qdrant/ | What is Qdrant? | What is Qdrant? | documentation | false | What is Qdrant? > What is Qdrant?
[Qdrant](https://github.com/qdrant/qdrant) is a vector similarity search engine that provides a production-ready
service with a convenient API to store, search, and manage points (i.e. vectors) with an additional
payload. You can think of the payloads as additional pieces of informa... | [
0.029867755249142647,
-0.04612737521529198,
-0.061277542263269424,
-0.0326552577316761,
0.03852282464504242,
-0.02431708201766014,
0.11203552037477493,
0.030963627621531487,
0.08973121643066406,
-0.05163015425205231,
0.03921136632561684,
-0.013190364465117455,
0.04281579330563545,
-0.01565... |
5f781616-b915-51be-9564-26f936827d72 | /documentation/datasets/ | Practice Datasets | Qdrant on Hugging Face | documentation | false | Practice Datasets > Qdrant on Hugging Face
[Hugging Face](https://huggingface.co/) provides a platform for sharing and using ML models and
datasets. [Qdrant](https://huggingface.co/Qdrant) is one of the organizations there! We aim to
provide you with datasets containing neural embeddings that you can use to practice... | [
0.057026274502277374,
-0.017712829634547234,
-0.0720406323671341,
-0.06510523706674576,
0.06085311621427536,
-0.030915573239326477,
0.07436846196651459,
0.036386795341968536,
0.05234888941049576,
-0.019831901416182518,
0.05140729993581772,
0.014430548064410686,
0.06274636089801788,
-0.0435... |
5f7fdffc-adff-59f5-8abe-7c6d4e080d9d | /documentation/manage-data/quantization/ | Quantization | Setting Up Quantization in Qdrant > Setting Up Scalar Quantization | documentation | true | Quantization > Setting Up Quantization in Qdrant > Setting Up Scalar Quantization
To enable scalar quantization, you need to specify the quantization parameters in the `quantization_config` section of the collection configuration.
When enabling scalar quantization on an existing collection, use a PATCH request or the... | [
0.03514240309596062,
-0.05735090374946594,
-0.0189092718064785,
-0.024215899407863617,
0.02565210685133934,
-0.039286792278289795,
0.035793472081422806,
0.0540555939078331,
0.10670807212591171,
-0.030270671471953392,
0.01902123913168907,
0.025151601061224937,
0.03759625181555748,
-0.048241... |
5f8953ac-3e62-5798-94e0-d8821c544c2b | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantEntityList | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantEntityList
QdrantEntityList contains a list of QdrantEntity objects
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `kind` _string_ | `QdrantEntityList` | | |
| `metadata` _[ListMeta](https:... | [
0.04159080609679222,
-0.02447071485221386,
-0.021902533248066902,
-0.0700051411986351,
0.07352554053068161,
-0.06951446831226349,
0.05428062006831169,
0.07360246777534485,
0.05999055877327919,
-0.06250347197055817,
0.04827797785401344,
0.027808012440800667,
0.04644007980823517,
-0.00731532... |
5f8972dd-9cd8-5727-b958-e9e41c21604b | /documentation/ops-optimization/optimizer/ | Optimizer | Merge Optimizer | documentation | true | Optimizer > Merge Optimizer
Qdrant uses the Merge Optimizer to manage the number of segments in its storage system, ensuring efficient data organization and query performance. Temporary segments may be created during processes like optimization, such as copy-on-write segments, which help facilitate operations.
Qdrant... | [
0.015872206538915634,
-0.04528340697288513,
-0.032784078270196915,
-0.00910425465553999,
0.06406852602958679,
-0.04255510866641998,
0.06780318915843964,
0.01875438168644905,
0.06353644281625748,
-0.020966123789548874,
0.011430088430643082,
0.004943167325109243,
0.04711470007896423,
-0.0671... |
5f949ef2-d862-5f7e-b0f3-92f12742434a | /documentation/tutorials-operations/secure-and-expose-hybrid-cloud/ | Securing and Exposing a Hybrid Cloud Cluster | Add TLS at the Qdrant Level | documentation | true | Securing and Exposing a Hybrid Cloud Cluster > Add TLS at the Qdrant Level
In this step, we will need to generate an SSL certificate: for this tutorial we will be using a self-signed one from `mkcert`, which is fine for testing but should not be used in production. Use a certificate from your internal CA or a public i... | [
0.062123630195856094,
-0.03867926448583603,
-0.042160529643297195,
-0.006100637372583151,
0.023263564333319664,
-0.0326518751680851,
0.07004626840353012,
0.019125262275338173,
0.05638951435685158,
-0.031701069325208664,
0.004222142975777388,
-0.0034083800856024027,
0.044453516602516174,
-0... |
5fac8ae3-7c9c-56f6-ae33-08235da1cb7f | /documentation/tutorials-develop/code-search/ | Semantic Search for Code | Querying the codebase | documentation | false | Semantic Search for Code > Querying the codebase
| module | file_name | score | signature ... | [
0.03886967897415161,
-0.04448781535029411,
-0.03342539072036743,
0.00451013445854187,
0.03932357206940651,
-0.005954180844128132,
0.0656936913728714,
0.04993937537074089,
0.06419380009174347,
-0.018231572583317757,
0.04503757134079933,
0.02270694449543953,
0.0036017843522131443,
-0.0305451... |
5fe5eafd-16a5-5445-ad0a-22844a5d787e | /documentation/tutorials-develop/neural-search/ | Build a Semantic Search API | Next Steps | documentation | false | Build a Semantic Search API > Next Steps
A [live online demo](https://qdrant.to/semantic-search-demo) searches the same startup dataset.
You can try it to get an intuition for cases when the neural search is useful.
The demo contains a selector between semantic, keyword, and hybrid searches.
You can switch between the... | [
0.023315420374274254,
-0.046872422099113464,
-0.07975376397371292,
-0.023287339136004448,
0.06576304137706757,
-0.012034369632601738,
0.08403829485177994,
0.04588852822780609,
0.04171178117394447,
-0.0537065826356411,
0.05615762621164322,
0.04188195616006851,
0.07303096354007721,
-0.018945... |
5fe8dd2b-dc23-54d8-bc88-5a2e59cbdd85 | /course/multi-vector-search/module-2/visual-interpretability/ | Visual Interpretability of ColPali | Computing Token-Patch Similarities | course | true | Visual Interpretability of ColPali > Computing Token-Patch Similarities
To visualize what ColPali focuses on, we compute the similarity between each query token and all document patches. For a given query token embedding, we can calculate its similarity with each of the 1024 patch embeddings:
```python
import numpy a... | [
0.051399897783994675,
-0.039300158619880676,
-0.061311107128858566,
-0.08433864265680313,
0.07596378773450851,
-0.03871822729706764,
0.06937187910079956,
0.07627398520708084,
0.03397177904844284,
-0.03234079107642174,
0.0663636103272438,
-0.0038570447359234095,
0.051713746041059494,
-0.035... |
5fea1369-bdcd-5665-a7d8-2a7d4579bb0f | /documentation/ops-configuration/running-with-gpu/ | Running with GPU | documentation | false | Running with GPU
Starting from version v1.13.0, Qdrant offers support for GPU acceleration.
However, GPU support is not included in the default Qdrant binary due to additional dependencies and libraries. Instead, you will need to use dedicated Docker images with GPU support ([NVIDIA](#nvidia-gpus), [AMD](#amd-gpus)). | [
0.007028392516076565,
-0.059558846056461334,
-0.04660773649811745,
-0.02764945849776268,
0.048437200486660004,
-0.030565980821847916,
0.06990085542201996,
0.030758971348404884,
0.07397506386041641,
-0.010244915261864662,
0.07375642657279968,
-0.013688839972019196,
0.04662381112575531,
-0.0... | |
5ff365df-510a-56bd-a387-9858a97e7da2 | /documentation/installation/ | Installation | Production > Qdrant Kubernetes Operator | documentation | false | Installation > Production > Qdrant Kubernetes Operator
We provide a Qdrant Enterprise Operator for Kubernetes installations as part of our [Qdrant Private Cloud](/documentation/private-cloud/) offering. For more information, [use this form](https://qdrant.to/contact-us) to contact us. | [
-0.007076060399413109,
-0.04197951778769493,
-0.06408552825450897,
-0.06688341498374939,
0.04028746485710144,
-0.010978992097079754,
0.07083931565284729,
0.03379964828491211,
0.07175472378730774,
-0.019749045372009277,
0.0033583666663616896,
0.005656012333929539,
0.06726264208555222,
-0.04... |
6016b489-b376-59a9-912e-77c33032a4a9 | /course/essentials/day-3/hybrid-search/ | Hybrid Search and the Universal Query API | The Challenge: Different Users, Different Search Needs > Real-World Complexity: Legal Search Example | course | false | Hybrid Search and the Universal Query API > The Challenge: Different Users, Different Search Needs > Real-World Complexity: Legal Search Example
Unfortunately, reality is never that simple. Some of your users might be domain experts and use the same terminology as you do, so implementing just keyword-based search will... | [
0.011370941065251827,
-0.05055208131670952,
-0.08037812262773514,
-0.0369400680065155,
0.05561321601271629,
-0.04540454223752022,
0.062430959194898605,
0.018797529861330986,
0.06267008185386658,
-0.040140967816114426,
0.030320623889565468,
0.04155251011252403,
0.08951348066329956,
-0.02904... |
60345caa-94be-5fef-b017-eae0c61ca1ad | /documentation/overview/what-is-qdrant/ | What is Qdrant? | What Are Vector Databases? | documentation | false | What is Qdrant? > What Are Vector Databases?
Here's a quick overview of the three:
- [**Cosine Similarity**](https://en.wikipedia.org/wiki/Cosine_similarity) - Cosine similarity
is a way to measure how similar two vectors are. To simplify, it reflects whether the vectors
have the same direction (similar) or are pole... | [
0.061304833739995956,
-0.03919164836406708,
-0.05510785058140755,
-0.04137832298874855,
0.048934392631053925,
-0.01630539447069168,
0.07627269625663757,
0.02394225262105465,
0.09195861220359802,
-0.047575388103723526,
0.06213938817381859,
0.004757147282361984,
0.04306787997484207,
0.007948... |
603c66d0-2a88-546e-9ad7-4798bc82ffb9 | /course/essentials/day-5/universal-query-api/ | The Universal Query API | Next | course | false | The Universal Query API > Next
In our next lesson, you'll bring these building blocks together in a personalized recommendation pipeline. You'll learn how to retrieve candidate from three different vector representations, fuse their signals, rerank with ColBERT, apply user-segment filters, and deliver highly relevant ... | [
0.032003168016672134,
-0.038301266729831696,
-0.025251708924770355,
-0.05162706971168518,
0.073090560734272,
-0.01682593673467636,
0.0387994647026062,
0.0727776512503624,
0.05705815926194191,
0.009433498606085777,
0.02653871290385723,
0.05561494454741478,
0.07512843608856201,
-0.0296002477... |
60469527-6246-52f6-aa82-92efb33740b2 | /articles/hyperbolic-embeddings-qdrant/ | Why Hyperbolic Embeddings Matter for Hierarchical Data | Superpowers of Hyperbolic Embeddings > Dimensional Efficiency | article | false | Why Hyperbolic Embeddings Matter for Hierarchical Data > Superpowers of Hyperbolic Embeddings > Dimensional Efficiency
When the geometry matches the data, you can often represent the same structure with fewer dimensions.
WordNet gives a concrete example. Its noun hierarchy contains relationships such as `poodle → dog... | [
0.06516384333372116,
0.007034245412796736,
-0.036238592118024826,
-0.050316665321588516,
0.05627484247088432,
-0.0476599745452404,
0.07295040041208267,
0.025278108194470406,
0.07859691232442856,
-0.021928604692220688,
0.02206159196794033,
0.007232484873384237,
0.09713274240493774,
-0.02633... |
6055bb84-7078-5671-9d5d-08122087890a | /documentation/fastembed/fastembed-splade/ | Working with SPLADE | Setup | documentation | true | Working with SPLADE > Setup
First, install FastEmbed.
```python
pip install -q fastembed
```
Next, import the required modules for sparse embeddings and Python’s typing module.
```python
from fastembed import SparseTextEmbedding, SparseEmbedding
```
You may always check the list of all supported sparse embedding m... | [
0.061727020889520645,
-0.04092567414045334,
0.0016262754797935486,
-0.049125541001558304,
0.05440617725253105,
-0.06466734409332275,
0.06432017683982849,
0.02350497990846634,
0.031671103090047836,
-0.012627832591533661,
0.04067697748541832,
0.04741649329662323,
0.04818595200777054,
-0.0335... |
606679f8-3326-572d-ab65-35894204d662 | /documentation/tutorials-search-engineering/multi-representation-search/ | Multi-Representation Search | Retrieval | documentation | true | Multi-Representation Search > Retrieval
The recommended pipeline fuses four prefetches with Reciprocal Rank Fusion and groups the results by document. One Query API call covers retrieval, fusion, and grouping:
```python
def retrieve(query, limit=10, group_size=3, tags=None):
dense_query = models.Document(text=qu... | [
-0.0015784066636115313,
-0.03177611902356148,
-0.021121077239513397,
-0.0673636868596077,
0.07917899638414383,
-0.03856014087796211,
0.03867544233798981,
0.05497937276959419,
0.046219199895858765,
-0.009810295887291431,
0.009580451995134354,
0.018454669043421745,
0.03310874104499817,
-0.03... |
6094e487-39eb-516a-82ae-6bf3edddabbc | /documentation/edge/edge-synchronization-guide/ | Synchronize with a Server | Synchronizing Qdrant Edge with a Server > 3. Implement a Dual-Write Mechanism | documentation | true | Synchronize with a Server > Synchronizing Qdrant Edge with a Server > 3. Implement a Dual-Write Mechanism
With both Edge Shards initialized, you can implement a dual-write mechanism in your application as outlined in [Update a Server Collection from an Edge Shard](/documentation/edge/edge-data-synchronization-patterns... | [
0.014540739357471466,
-0.035088397562503815,
-0.06286787986755371,
0.005620592273771763,
0.05831774324178696,
-0.04645054414868355,
0.07871773838996887,
0.051183853298425674,
0.07221943140029907,
-0.0022551012225449085,
0.040476664900779724,
0.022473417222499847,
0.02018558420240879,
-0.00... |
60a35509-fca5-5d18-9af3-30dd1880c5d5 | /documentation/tutorials-develop/neural-search/ | Build a Semantic Search API | Prepare Sample Dataset | documentation | true | Build a Semantic Search API > Prepare Sample Dataset
To conduct a neural search on startup descriptions, you must first encode the description data into vectors. To process text, you can use any pre-trained embedding model.
In this tutorial, Qdrant Cloud runs the model for you through [Cloud Inference](/documentation... | [
0.05552113056182861,
-0.0792621374130249,
-0.024525821208953857,
-0.031100034713745117,
0.07081501185894012,
-0.010560987517237663,
0.05198855698108673,
0.035420771688222885,
0.05517285689711571,
-0.020154912024736404,
0.03770329803228378,
0.013504977338016033,
0.07420986890792847,
-0.0444... |
60a449d6-8894-567c-a44d-8f98be0356c8 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > KubernetesDistribution | documentation | false | API Reference > qdrant.io/v1 > Resource Types > KubernetesDistribution
_Underlying type:_ _string_
_Appears in:_
- [QdrantCloudRegionStatus](#qdrantcloudregionstatus)
| Field | Description |
| --- | --- |
| `unknown` | |
| `aws` | |
| `gcp` | |
| `azure` | |
| `do` | |
| `scaleway` | |
| `openshift` | |
| `li... | [
0.03895356506109238,
-0.036560364067554474,
-0.01889740861952305,
-0.04533540457487106,
0.07433304190635681,
-0.017824295908212662,
0.05665275827050209,
0.06516323238611221,
0.0637313723564148,
-0.02483397163450718,
0.03882264345884323,
0.0034701405093073845,
0.042162347584962845,
-0.01655... |
60ac81fd-1689-5ebe-ae14-11b3d7fffdac | /documentation/tutorials-basics/reranking-hybrid-search/ | Hybrid Search with Reranking | Implementation > Retrieval | documentation | false | Hybrid Search with Reranking > Implementation > Retrieval
| Position | Title | Description |
|----------|-------|-------------|
| 1 | The Time Machine | A Victorian scientist travels far into the future to witness civilization's fate. |
| 2 | Slaughterhouse-Five | A nonlinear, time-tripping reflection on war and fate.... | [
0.05185173451900482,
-0.006425928324460983,
-0.08268647640943527,
-0.029722847044467926,
0.09861583262681961,
0.02005006931722164,
0.025801748037338257,
0.021086253225803375,
0.05194273218512535,
0.012433602474629879,
0.02338196523487568,
-0.02090904861688614,
0.06596970558166504,
-0.00896... |
60c8237c-4de8-53a4-a717-82de2269f358 | /documentation/search-tuning/when-your-collection-outgrows-ram/ | When Your Collection Outgrows RAM | What Rescoring Recovers | documentation | false | When Your Collection Outgrows RAM > What Rescoring Recovers
Two measurements answer different questions here. An exact search scans every vector and gives the reference result, while graph search trades some of those neighbors for lower latency.
`Recall@10` against exact search is the share of the exact top 10 that a... | [
0.03086869791150093,
-0.0490335114300251,
-0.04876769334077835,
-0.03991846740245819,
0.0663779079914093,
-0.0476287379860878,
0.032407958060503006,
0.04507232829928398,
0.09725973010063171,
-0.03650808334350586,
0.006451570428907871,
0.01175738126039505,
0.05363914370536804,
0.01218164153... |
60e44e8d-f4c7-5ebd-9352-926c6664f0f8 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Scalar Quantization > Theoretical Background > Distance Calculation | article | false | Scalar Quantization for Vector Search > Scalar Quantization > Theoretical Background > Distance Calculation
We do not store the vectors in the collections represented by `int8` instead of `float32`
just for the sake of compressing the memory. But the coordinates are being used while we
calculate the distance between... | [
0.052446380257606506,
-0.014510838314890862,
-0.014073643833398819,
-0.028564786538481712,
0.04562896490097046,
-0.008727156557142735,
0.05358625203371048,
0.06056874245405197,
0.10752864181995392,
-0.031402118504047394,
0.036617353558540344,
0.031160656362771988,
0.0029818271286785603,
-0... |
60ee805b-566b-57c0-aa47-fcb26be4ac6d | /documentation/fastembed/fastembed-rerankers/ | Reranking with FastEmbed | Rerankers | documentation | false | Reranking with FastEmbed > Rerankers
A reranker is a model that improves the ordering of search results. A subset of documents is initially retrieved using a fast, simple method (e.g., BM25 or dense embeddings). Then, a reranker -- a more powerful, precise, but slower and heavier model -- re-evaluates this subset to r... | [
0.006743361707776785,
-0.04306894540786743,
-0.08335597813129425,
-0.09497632831335068,
0.08297151327133179,
-0.02559681050479412,
0.08025162667036057,
0.03612247854471207,
0.05252926051616669,
0.003600760130211711,
0.011037029325962067,
0.02537781186401844,
0.050108104944229126,
-0.008498... |
60eedb60-9bde-5b66-9d0c-199baef1b0fd | /documentation/frameworks/mastra/ | Mastra | Methods > deleteIndex() | documentation | false | Mastra > Methods > deleteIndex()
| Name | Type | Description |
|-------------|----------|----------------------------------|
| `indexName` | `string` | Name of the index to delete | | [
0.04629487544298172,
-0.02819395437836647,
-0.017854003235697746,
-0.013201821595430374,
0.018139835447072983,
-0.0006124385399743915,
-0.0008699373574927449,
0.014859523624181747,
0.05739564076066017,
-0.025658899918198586,
0.048498962074518204,
0.04746441915631294,
0.05929405987262726,
-... |
60f1d607-d9f2-5e88-b807-5ccba794269c | /documentation/ops-optimization/optimizer/ | Optimizer | Per-Collection Optimizer Configuration | documentation | true | Optimizer > Per-Collection Optimizer Configuration
The configuration file determines global defaults for all collections. You can also configure optimizer parameters per collection at [creation time](/documentation/manage-data/collections/#create-a-collection), or [update](/documentation/manage-data/collections/#updat... | [
-0.00486546428874135,
-0.029323795810341835,
-0.03819519281387329,
-0.050042539834976196,
0.07059017568826675,
-0.04298325255513191,
-0.0048226239159703255,
0.06400502473115921,
0.06955601274967194,
0.0011199434520676732,
0.007973711006343365,
0.007657518610358238,
0.0468362458050251,
-0.0... |
610b4400-21ec-5bb3-be2d-4c1e68584c54 | /documentation/embeddings/jina-embeddings/ | Jina AI | documentation | false | Jina AI
[Jina AI](https://jina.ai/embeddings/), now part of Elastic, provides text, code, and multimodal embedding models through the Jina Embedding API. There are two ways to use them with Qdrant:
- Call the Jina API from your application and send the vectors to Qdrant. This works with any Qdrant deployment, and it'... | [
0.06827091425657272,
-0.03084455616772175,
-0.032720696181058884,
-0.04396181181073189,
0.0522785484790802,
-0.013058253563940525,
0.07145621627569199,
0.032261237502098083,
0.02063286304473877,
-0.018822509795427322,
0.06576231867074966,
-0.004157979041337967,
0.05870436131954193,
-0.0387... | |
611c6602-11ff-5d20-afce-d0e04a332dc9 | /documentation/ops-monitoring/slow-request-log/ | Slow Request Log | documentation | false | Slow Request Log
*Available as of v1.16.0 (beta). Behavior may change in future releases.*
The slow request log records the slowest unique operations on a node since startup. Use it to identify which queries are responsible for high latency.
The log keeps up to 32 entries per request type. Entries are deduplicated b... | [
0.018963633105158806,
-0.03636135160923004,
-0.05725770816206932,
-0.04502269625663757,
0.0549459345638752,
-0.038886718451976776,
0.034158505499362946,
0.0354541651904583,
0.06443995237350464,
-0.022291623055934906,
0.015032593160867691,
0.045571018010377884,
0.030736884102225304,
-0.0442... | |
611c7438-0147-5702-a8b4-089feeeba244 | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | Did we Solve the Vocabulary Mismatch Yet? > Internal Document Expansion | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ > Did we Solve the Vocabulary Mismatch Yet? > Internal Document Expansion
Let’s assume we don’t care about the context of query terms, so we can treat them as independent words that we combine in random order to get
the result. Then, for each contextualized term... | [
0.07765799760818481,
-0.036976419389247894,
-0.02489902265369892,
-0.04254880174994469,
0.06732096523046494,
-0.04150102287530899,
0.0632910206913948,
0.019616369158029556,
0.07964415103197098,
-0.03168259188532829,
-0.008608135394752026,
0.0401582233607769,
0.05759936943650246,
-0.0224622... |
613c1a15-5158-5158-bfdf-dcc69cd1ee3c | /course/essentials/day-3/hybrid-search-demo/ | Demo: Implementing a Hybrid Search System | Evaluation Considerations | course | false | Demo: Implementing a Hybrid Search System > Evaluation Considerations
**Did fusion improve search quality?** We can't definitively say without proper evaluation. Here's why:
### The Challenge of Search Quality
- **Subjective relevance**: "Best results" depend on unknown user intentions
- **No ground truth**: We don'... | [
0.02068493515253067,
-0.051363032311201096,
-0.0839066356420517,
-0.04624219983816147,
0.04160767048597336,
-0.02686738222837448,
0.07685980945825577,
0.02132728137075901,
0.08222311735153198,
-0.039121709764003754,
0.02661651000380516,
0.006296103820204735,
0.09252319484949112,
-0.0271701... |
614e049e-50aa-55c2-8af7-fb7f63bbac18 | /course/multi-vector-search/module-1/maxsim-distance/ | MaxSim Distance Metric | Understanding MaxSim Step-by-Step > The Intuition Behind MaxSim | course | false | MaxSim Distance Metric > Understanding MaxSim Step-by-Step > The Intuition Behind MaxSim
MaxSim implements **token-level relevance matching**. Each query term actively seeks its most relevant counterpart in the document. Unlike single-vector search where you compare one query vector to one document vector (one-to-one)... | [
0.027259286493062973,
-0.035553138703107834,
-0.0316874161362648,
-0.00992453284561634,
0.06724710762500763,
-0.028028171509504318,
0.029627930372953415,
0.0005479680257849395,
0.067331962287426,
-0.054196812212467194,
0.022275317460298538,
0.01662958785891533,
0.09856907278299332,
-0.0077... |
6151d07a-04e9-59ef-824f-35a3f92f5a09 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Use Labels to Choose a k Range | documentation | false | How to Tune Hybrid Search in Qdrant > Use Labels to Choose a k Range
Qdrant scores a document at position `pos` in one prefetch as `1 / ((pos + 1) / weight + k - 1)`, then sums across prefetches. With equal weights that reduces to `1 / (pos + k)`, and `k` alone decides how steeply the head of a list outranks its tail.... | [
0.03753282129764557,
-0.058860741555690765,
-0.044658415019512177,
-0.039302513003349304,
0.07425631582736969,
-0.04491395503282547,
0.036332644522190094,
0.03128630295395851,
0.0848291888833046,
-0.012587922625243664,
0.0035028757993131876,
0.01956128142774105,
0.0560152567923069,
-0.0097... |
61524c20-f035-5acf-a6f1-6823c5a65537 | /documentation/embeddings/qdrant-cloud-inference/ | Qdrant Cloud Inference | Models | documentation | false | Qdrant Cloud Inference > Models
Dense models:
`qdrant/clip-vit-b-32-text` and `qdrant/clip-vit-b-32-vision` share a vector space, so you can embed images with the vision model and search them with text.
Sparse models:
Multivector models:
For pricing, context windows, and usage, see the cluster's Inference tab in t... | [
0.0679815337061882,
-0.042766816914081573,
-0.03547877073287964,
-0.05498230457305908,
0.06817472726106644,
-0.025484532117843628,
0.10233136266469955,
0.04323231056332588,
0.042474113404750824,
-0.029970405623316765,
0.04238284006714821,
0.01909351721405983,
0.06561055779457092,
-0.027490... |
61672a1f-87d8-5cf6-8c12-be98d465abc9 | /documentation/migrate-to-qdrant/ | Migration Tool | Universal CLI Options | documentation | false | Migration Tool > Universal CLI Options
These flags apply to all source types:
| Flag | Default | Description |
| :--- | :--- | :--- |
| `--migration.batch-size` | 50 | Points per upsert batch |
| `--migration.restart` | false | Ignore saved progress, start fresh |
| `--migration.create-collection` | true | Auto-creat... | [
0.033041562885046005,
-0.0770806074142456,
-0.010065724141895771,
-0.029418937861919403,
0.05530448630452156,
-0.03728862479329109,
0.06695304811000824,
0.05419713258743286,
0.02961641736328602,
-0.05232182890176773,
0.033670295029878616,
0.02943596802651882,
0.03924763947725296,
-0.015606... |
6174dec9-2268-55df-b370-758b1fb3078b | /course/essentials/day-3/hybrid-search/ | Hybrid Search and the Universal Query API | Beyond Fusion: Advanced Reranking | course | false | Hybrid Search and the Universal Query API > Beyond Fusion: Advanced Reranking
Fusion is not the only way to build a hybrid search. Sometimes, you have a bigger set of weak retrievers and one strong reranker, which might be:
- A different neural model, such as a **cross-encoder**
- A more sophisticated dense retriever... | [
0.010098547674715519,
-0.04197743162512779,
-0.09370265901088715,
-0.048699621111154556,
0.08243144303560257,
-0.02878374233841896,
0.06276868283748627,
0.03211585432291031,
0.0708560049533844,
-0.013533653691411018,
0.038272179663181305,
0.016255713999271393,
0.0711512342095375,
-0.015861... |
61791740-af7d-589c-825f-c052d6eef78e | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 2: Transactional Outbox Pattern > When to Use This | documentation | false | Keeping Postgres and Qdrant in Sync > Tier 2: Transactional Outbox Pattern > When to Use This
- **Most production applications** with moderate write throughput
- When Qdrant availability shouldn't impact your write path
- When you can tolerate seconds of sync lag
- **The recommended default for the majority of product... | [
0.017397822812199593,
-0.04797915741801262,
-0.029420848935842514,
-0.01829754374921322,
0.013143830932676792,
-0.06137349084019661,
0.057606302201747894,
0.015297978185117245,
0.09193506091833115,
-0.014562523923814297,
0.03699661046266556,
0.009787878952920437,
0.06624096632003784,
-0.03... |
617bde9e-6cb5-523a-9518-800f050a0c80 | /documentation/tutorials-develop/search-as-you-type/ | Semantic Search As You Type | How It Works | documentation | false | Semantic Search As You Type > How It Works
The search service answers each keystroke in one of three ways. A longer query is embedded and sent to Qdrant. A short prefix that is in the cache skips the embedding model: Qdrant reads the stored embedding of the prefix with a recommend query and `lookup_from`. A short pref... | [
0.06075165048241615,
-0.048184413462877274,
-0.02795509621500969,
-0.01874518394470215,
0.0566062405705452,
-0.02126985229551792,
0.07113351672887802,
0.04053294286131859,
0.06133550778031349,
-0.013110279105603695,
0.03180195018649101,
0.012284116819500923,
0.04006456211209297,
-0.0145117... |
617ed9a4-8037-566f-8310-e28788415f27 | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Migrate Using Named Vectors > Step 1: Add the New Named Vector | documentation | true | Migrate to a New Embedding Model > Migrate Using Named Vectors > Step 1: Add the New Named Vector
Add the new model's vector schema to the existing collection. This is a schema-only operation: no segments are rebuilt and no existing point data is modified. The new vector is queryable immediately, but queries return no... | [
0.046336300671100616,
-0.058374546468257904,
-0.006388758309185505,
-0.030912915244698524,
0.02997943013906479,
-0.012414064258337021,
0.03359324485063553,
0.0426032617688179,
0.04941511154174805,
-0.01428720448166132,
0.022123901173472404,
0.04295080527663231,
0.03569320961833,
-0.0538697... |
6196cc36-ceee-555c-98a4-724f361fe40e | /course/essentials/day-5/universal-query-demo/ | Demo: Universal Query for Hybrid Retrieval | Step 2: The Universal Query in Action > Set Up Parallel Prefetch Queries | course | true | Demo: Universal Query for Hybrid Retrieval > Step 2: The Universal Query in Action > Set Up Parallel Prefetch Queries
Next, we configure our hybrid retrieval with two concurrent searches:
```python
# Prefetch queries - global filter will be automatically applied to both
hybrid_query = [
# Dense retrieval: semanti... | [
0.027591543272137642,
-0.04284326359629631,
-0.07393767684698105,
-0.018139846622943878,
0.0737258717417717,
-0.029464615508913994,
0.0330042690038681,
0.041943274438381195,
0.0852566659450531,
-0.02028599940240383,
0.027287036180496216,
0.036854423582553864,
0.06805943697690964,
-0.018181... |
6199f336-5b27-57e6-8c46-bb3f1de1c736 | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | One collection, many tenants | documentation | false | How to Implement Multitenancy and Custom Sharding in Qdrant > One collection, many tenants
When working with Qdrant, you can upsert all your data to a single collection, and then partition each vector via its payload. This means that all your users are leveraging the power of a single Qdrant cluster, but their data is... | [
0.016612879931926727,
-0.0263545960187912,
-0.07242102921009064,
-0.03241173177957535,
0.05293332412838936,
-0.0373750776052475,
0.07310774177312851,
0.03676316514611244,
0.0782744362950325,
-0.0354962982237339,
0.010670664720237255,
0.04039299488067627,
0.06684237718582153,
-0.01818822510... |
61a92aa4-8674-586d-9def-2a7ee6a13b4a | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | Why did we use a CLIP model? | documentation | false | Multimodal Food Search Demo > Why did we use a CLIP model?
CLIP is a neural network that can be used to encode both images and texts into vectors. And more importantly, both images and texts are vectorized into the same
latent space, so we can compare them directly. This lets you perform semantic search on images usin... | [
0.029157958924770355,
-0.050825707614421844,
-0.07519246637821198,
-0.02176514081656933,
0.0829501524567604,
-0.01146301906555891,
0.09871507436037064,
0.04364100843667984,
0.02150863967835903,
0.005065965466201305,
0.004337603691965342,
0.015354424715042114,
0.055716175585985184,
-0.04853... |
61ae5ccc-d15f-5637-a874-bb09edf77f79 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Key Takeaways | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Key Takeaways
This article describes our attempt to make a lightweight sparse neural retriever that is able to generalize to out-of-domain data. Sparse neural retrieval has a lot of potential, and we hope to see it gain more traction. | [
0.026828501373529434,
-0.03085317648947239,
-0.027317116037011147,
-0.05226413905620575,
0.061246298253536224,
-0.07393301278352737,
0.0726611539721489,
0.03555949777364731,
0.048824895173311234,
-0.005291863810271025,
-0.007263608742505312,
0.057871781289577484,
0.06757358461618423,
-0.00... |
61af94c7-3fea-53ef-88fe-79f0764b4465 | /documentation/search-tuning/when-a-reranker-is-worth-it/ | When Is a Reranker Worth It? | Diagnose a Loss Before You Stop | documentation | false | When Is a Reranker Worth It? > Diagnose a Loss Before You Stop
If the reranker loses at 10 candidates, go back to fit and measure it. Tokenize a sample of your query-document pairs with the model's tokenizer. Compare the 95th percentile length with the model's window: a longer pair gets truncated, and the model scores... | [
0.029263414442539215,
-0.025419512763619423,
-0.05894683301448822,
-0.026716729626059532,
0.051554519683122635,
-0.03698400780558586,
0.035726793110370636,
-0.015403159894049168,
0.059065233916044235,
-0.03765147551894188,
0.02879474312067032,
0.020039405673742294,
0.06125015765428543,
-0.... |
61c43930-348e-59ed-9747-7830c2a67c64 | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Dissecting Feedback | article | false | Relevance Feedback in Qdrant > Dissecting Feedback
Let's talk about how a very small amount of feedback can be used most effectively, what relevance signals we can extract from it, and how exactly.
### Context Pairs
If we show only one document to the feedback model, it is hard for it to say whether it is already a ... | [
0.0167472492903471,
-0.040705226361751556,
-0.06590355932712555,
-0.028289562091231346,
0.0345550999045372,
0.005046348087489605,
0.07014847546815872,
0.024954557418823242,
0.05902433022856712,
-0.016157515347003937,
-0.02854948304593563,
0.009562519378960133,
0.05455438047647476,
-0.04578... |
61cb69e2-aab5-5184-b5ea-ca84ff1c1cea | /documentation/production-operations/bulk-data-import/ | Bulk Uploading Data to Qdrant | Option 4: Reduce Sparse Index Memory During Uploads | documentation | true | Bulk Uploading Data to Qdrant > Option 4: Reduce Sparse Index Memory During Uploads
_Sparse vectors_
For large sparse vector workloads, one option is to store the sparse vector index on disk. The sparse index is pinned in RAM by default, so this can help reduce memory usage when the index becomes large.
 consensus protocol to maintain consistency regarding the cluster topology and the collections structure. Raft consensus only applies to cluster metadata, not to the data itself:
- Collection operations are part of the consensus. This ... | [
0.047357626259326935,
-0.03063633106648922,
-0.043597545474767685,
-0.03333452343940735,
0.04663396626710892,
-0.04614727199077606,
0.08494260162115097,
0.04703301191329956,
0.04727180302143097,
-0.04252902418375015,
0.06723957508802414,
-0.010098541155457497,
0.026032164692878723,
0.01015... |
61ce99db-ba45-541a-8bb2-e6e7bd0eb2f1 | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Understanding Reranking > Working | documentation | false | Reranking for Better Search > Understanding Reranking > Working
Picture this: You walk into a massive library and ask for a book on "climate change." The librarian pulls out a dozen books for you—some are scientific papers, others are personal essays, and one’s even a novel. Sure, they’re all relevant, but the first o... | [
0.01575366035103798,
-0.01904311217367649,
-0.09351813048124313,
-0.04754278436303139,
0.07148165255784988,
-0.035331182181835175,
0.037794217467308044,
0.033840931951999664,
0.06781618297100067,
-0.019803205505013466,
-0.011013981886208057,
0.035346582531929016,
0.06426195055246353,
-0.02... |
61d03249-dfde-533a-abda-fbcc683012bf | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantReleaseList | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantReleaseList
QdrantReleaseList contains a list of QdrantRelease
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `kind` _string_ | `QdrantReleaseList` | | |
| `metadata` _[ListMeta](https://ku... | [
0.03687071427702904,
-0.02981131337583065,
-0.03707868233323097,
-0.06881233304738998,
0.07987301051616669,
-0.05437513440847397,
0.04904627427458763,
0.05286675691604614,
0.04788034409284592,
-0.06931626051664352,
0.04936227947473526,
0.02128203772008419,
0.0639113113284111,
0.01327606104... |
6226161f-61d4-578f-8dcd-f7836964713c | /course/essentials/day-0/building-simple-vector-search/ | Implementing a Basic Vector Search | Step 6: Insert Points into the Collection | course | true | Implementing a Basic Vector Search > Step 6: Insert Points into the Collection
[Points](/documentation/manage-data/points/) are the core data entities in Qdrant. Each point contains:
- **ID**: A unique identifier
- **Vector Data**: An array of numerical values representing the data point in vector space
- **Payload (... | [
0.03421398997306824,
-0.046092063188552856,
-0.034532178193330765,
-0.030992336571216583,
0.0646144226193428,
-0.007483983878046274,
0.06939763575792313,
0.07608088105916977,
0.08757317066192627,
-0.026068976148962975,
0.009541867300868034,
0.017164820805191994,
0.013649916276335716,
-0.03... |
62275db1-8bb5-5be4-bfe6-eceac5ca8aa1 | /articles/dataset-quality/ | Detecting Dataset Errors with Similarity Search | Furniture web-marketplace | article | false | Detecting Dataset Errors with Similarity Search > Furniture web-marketplace
Let’s say you work on an online furniture marketplace.
In this case, to ensure a good user experience, you need to split items into different categories: tables, chairs, beds, etc.
One can arrange all the items manually and spend a lot of mon... | [
0.06531278789043427,
-0.017905190587043762,
-0.08315456658601761,
-0.021984770894050598,
0.06123821809887886,
-0.05391929671168327,
0.05782067030668259,
0.02873171679675579,
0.04884413257241249,
-0.024325521662831306,
0.01960589364171028,
0.057577598839998245,
0.09285323321819305,
-0.02675... |
623cbbf1-a7a5-5df9-8b86-6cd84c4fe7cf | /documentation/examples/multitenancy/ | Multitenancy with Qdrant | documentation | false | Multitenancy with Qdrant
If you are building a service that serves vectors for many independent users, and you want to isolate their
data, the best practice is to use a single collection with payload-based partitioning. This approach is
called **multitenancy**. Our guide on [Separate Partitions](/documentation/manage-... | [
0.03506721556186676,
-0.008619571104645729,
-0.051384903490543365,
-0.016330594196915627,
0.044136978685855865,
-0.04367340728640556,
0.06911417841911316,
0.03540141507983208,
0.08756866306066513,
-0.019507678225636482,
0.00459371879696846,
0.017607787624001503,
0.059467799961566925,
-0.01... | |
623df195-858b-5778-b6cc-aff6be38ba6b | /documentation/cloud-account-setup/ | Account Setup | Creating Additional Accounts | documentation | false | Account Setup > Creating Additional Accounts
You can create additional accounts from the **Create new Account** option in the account switcher, or from your **Accounts** page. Each account is isolated: it has its own set of clusters, permissions, and payment methods. For each account, you can decide which users get ac... | [
0.0041131568141281605,
-0.0117971021682024,
-0.07165708392858505,
-0.026570778340101242,
0.06663909554481506,
-0.045131802558898926,
-0.005943737458437681,
0.06720615923404694,
0.059780653566122055,
-0.040617380291223526,
0.0199000034481287,
0.03383947163820267,
0.04599825292825699,
-0.047... |
624ba594-7131-53f1-acf9-67166d90639b | /documentation/migration-guidance/diagnosing-discrepancies/ | Diagnosing Discrepancies | Configuration-Level Issues > Distance Metric Mismatch | documentation | true | Diagnosing Discrepancies > Configuration-Level Issues > Distance Metric Mismatch
**Diagnostic test:** Take a single query vector, compute its distance to a known target vector manually (using numpy), and compare against both systems:
```py
import numpy as np
query = np.array([...]) # Your query vector
target = np.a... | [
0.0581858828663826,
-0.018087025731801987,
-0.03762540593743324,
0.013567306101322174,
0.037971366196870804,
-0.006240690592676401,
0.0574646070599556,
0.0229698084294796,
0.08365775644779205,
0.004845202900469303,
0.021258344873785973,
-0.008081832900643349,
0.05710219219326973,
0.0052680... |
62667354-a0f4-5e9e-9732-f16f664b25c9 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Same Word, Different Language > Dense Multilingual Retrieval | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Same Word, Different Language > Dense Multilingual Retrieval
Multilingual dense encoders solve cross-lingual matching by construction: *"She won a prize"* and *"Ella ganó un premio"* land close together in embedding space. (At least in theory: many ... | [
0.07313432544469833,
-0.029021037742495537,
-0.05646615847945213,
-0.06549663096666336,
0.0753321722149849,
-0.049012359231710434,
0.06881458312273026,
0.013663005083799362,
0.08503466099500656,
-0.02521068975329399,
0.021944653242826462,
0.03894182667136192,
0.09310358762741089,
0.0086626... |
626fecb0-d207-5892-9042-2869ef3f6f26 | /articles/immutable-data-structures/ | Immutable Data Structures in Qdrant | Data Structures 101 | article | false | Immutable Data Structures in Qdrant > Data Structures 101
Those who took programming courses might remember that there is no such thing as a universal data structure.
Some structures are good at accessing elements by index (like arrays), while others shine in terms of insertion efficiency (like linked lists).
](https://colab.research.google.com/github/qdrant/examples/blob/master/code-search/code-search.ipynb) | |
|--------------|---------------------|--|----|
You too can enrich your... | [
0.04817815124988556,
-0.06114654988050461,
-0.059407707303762436,
-0.0063016172498464584,
0.0724494457244873,
-0.04001450911164284,
0.0525408573448658,
0.009364370256662369,
0.03406935930252075,
-0.011789166368544102,
0.05447423458099365,
-0.006595501210540533,
0.06649214029312134,
-0.0437... | |
62f5b458-b52c-513c-8b58-a7869b3051a5 | /documentation/edge/edge-synchronization-guide/ | Synchronize with a Server | Synchronizing Qdrant Edge with a Server | documentation | false | Synchronize with a Server > Synchronizing Qdrant Edge with a Server
To support having local updates as well as updates from a centralized server, implement a setup with two Edge Shards:
- A **mutable** Edge Shard that handles local data updates.
- An **immutable** Edge Shard that mirrors a shard from a collection on ... | [
0.023697860538959503,
-0.027712440118193626,
-0.07920566946268082,
-0.003382947761565447,
0.07424729317426682,
-0.02631966583430767,
0.10210178792476654,
0.00612370390444994,
0.07865459471940994,
-0.005104245152324438,
0.03807222843170166,
0.021901311352849007,
0.04185463860630989,
0.00476... |
62fd31e5-51ac-5c4a-a358-4d7df0c6ca68 | /documentation/search-tuning/hybrid-search/ | Hybrid Search in Qdrant | Fusion Merges Two Rankings Into One | documentation | false | Hybrid Search in Qdrant > Fusion Merges Two Rankings Into One
In Qdrant, a prefetch runs a search and passes its candidates to the main query. Hybrid search uses one prefetch for dense retrieval and another for sparse retrieval. Fusion combines their candidate lists into one ordering.
Dense similarity and BM25 scores... | [
0.055252499878406525,
-0.028291411697864532,
-0.06661289930343628,
-0.058535829186439514,
0.06484821438789368,
-0.04662957787513733,
0.05043020471930504,
0.04475570470094681,
0.06119031086564064,
-0.02014217898249626,
0.04720400273799896,
0.01864282228052616,
0.04055386036634445,
0.0172039... |
63246375-7aac-5d5f-add8-d6e9ba8c88cd | /documentation/agentic-tools/skills/ | Agent Skills | Available Hub Skills | documentation | false | Agent Skills > Available Hub Skills
| Skill | Use for |
| --- | --- |
| `qdrant-clients-sdk` | SDK setup and code examples across Python, TypeScript, Rust, Go, .NET, Java |
| `qdrant-scaling` | Data volume, QPS targets, latency budgets, horizontal vs. vertical decisions |
| `qdrant-performance-optimization` | Search s... | [
0.024208111688494682,
-0.030411815270781517,
-0.06518297642469406,
-0.010445318184792995,
0.09650660306215286,
-0.057753805071115494,
0.06402216851711273,
0.006384853273630142,
0.0818721354007721,
-0.03132278472185135,
0.059767380356788635,
0.011823677457869053,
0.038068413734436035,
-0.05... |
6339faeb-e2db-5a98-b578-6f9e9baaf6b6 | /documentation/tutorials-develop/serverless-semantic-search/ | Serverless Semantic Search | What You're Going to Build | documentation | false | Serverless Semantic Search > What You're Going to Build
You combine the embedding provider and the Qdrant instance into a semantic search, calling both services from a small Lambda function. The function reads the search text from the `q` query parameter of its URL.
 is a library designed to help preprocess, structure unstructured text documents for downstream machine learning tasks.
Qdrant can be used as an ingestion destination in Unstructured.
## Setup
Install Unstructured with the `qdrant` extra.
```bash
pip install "un... | [
0.044863443821668625,
-0.03804956376552582,
-0.0803602784872055,
-0.0143535565584898,
0.06596449762582779,
-0.03364231437444687,
0.06621081382036209,
0.05376129597425461,
0.03352382779121399,
-0.01628805510699749,
0.009375669062137604,
-0.03915997967123985,
0.03682544082403183,
-0.00467838... | |
63601b82-06f1-53b4-9257-f04285d161f3 | /documentation/tutorials-build-essentials/semantic-cache/ | Semantic Caching for RAG | Building the RAG (before the Cache) | documentation | true | Semantic Caching for RAG > Building the RAG (before the Cache)
In RAG, when a user asks a question, we search our knowledge base for matching context. The matched context is then passed to an LLM along with the prompt and user question for response generation.
Our knowledge base here contains short policy documents o... | [
-0.012266574427485466,
-0.03229142725467682,
-0.046222373843193054,
-0.047105833888053894,
0.06751279532909393,
-0.04233312979340553,
0.042747195810079575,
0.043266575783491135,
0.03336291015148163,
-0.050339438021183014,
0.018889833241701126,
0.04610338434576988,
0.05714500695466995,
-0.0... |
63798d41-dd26-5fc9-b8b7-42c737bb8820 | /course/multi-vector-search/module-1/ | Module 1: Multi-Vector Representations for Textual Data | course | false | Module 1: Multi-Vector Representations for Textual Data
Module 1
Dive into multi-vector text representations and discover how ColBERT changes the vector search landscape.
---
## Today's path
1. Late Interaction Basics
2. MaxSim Distance Metric
3. Use Cases for Multi-Vector Search
4. Problems of Multi-Vector Search... | [
0.07846266776323318,
-0.043062031269073486,
-0.03300978243350983,
-0.02334720827639103,
0.08599698543548584,
-0.04741648957133293,
0.0493975393474102,
0.05898016691207886,
0.06467581540346146,
-0.012676836922764778,
0.02878260612487793,
0.03403126448392868,
0.06363345682621002,
-0.04053825... | |
63826ed5-ba15-5d1d-b9f2-556db6ad2a71 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Hybrid search: combining sparse and dense vectors > Re-ranking | article | false | Understanding SPLADE and Sparse Vectors > Hybrid search: combining sparse and dense vectors > Re-ranking
You can use obtained results as a first stage of a two-stage retrieval process. In the second stage, you can re-rank the results from the first stage using a more complex model, such as [Cross-Encoders](https://www... | [
0.06834334880113602,
-0.049325525760650635,
-0.02067565731704235,
-0.06944948434829712,
0.0785883441567421,
-0.044700756669044495,
0.06252939999103546,
0.048116933554410934,
0.08134084194898605,
-0.010087800212204456,
0.020297840237617493,
0.024754444137215614,
0.06406053900718689,
-0.0196... |
6388344b-1c4e-50bf-9995-de8087ce2a7c | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantClusterRestoreList | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantClusterRestoreList
QdrantClusterRestoreList contains a list of QdrantClusterRestore objects
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `kind` _string_ | `QdrantClusterRestoreList` | | |... | [
0.0579119473695755,
-0.02931986004114151,
-0.01894865185022354,
-0.05716385319828987,
0.07470942288637161,
-0.06067772954702377,
0.04329720884561539,
0.039694659411907196,
0.052241332828998566,
-0.060469821095466614,
0.04369798302650452,
0.022415567189455032,
0.04143466427922249,
0.0171563... |
639d8de6-d641-5e80-83e4-c737c6530ff4 | /articles/product-quantization/ | Product Quantization for Vector Search | How Does Product Quantization Work? | article | false | Product Quantization for Vector Search > How Does Product Quantization Work?
Let’s assume we have a few vectors being added to the collection and that our optimizer decided
to start creating a new segment.
### Cutting the vector into pieces
First of all, our vectors are going to be divided into **chunks** aka **sub... | [
0.04299231246113777,
-0.04704195633530617,
-0.06234052777290344,
-0.026867445558309555,
0.07174720615148544,
-0.013103250414133072,
0.03991400822997093,
0.03601798787713051,
0.10195083916187286,
-0.03456486016511917,
0.029517946764826775,
0.0056708757765591145,
0.05444291979074478,
-0.0362... |
639f56c9-dbcb-5767-bb91-87477e564ca3 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval
Have you ever heard of sparse neural retrieval? If so, have you used it in production?
It's a field with excellent potential -- who wouldn't want to use an approach that combines the strengths of dense and term-based text retrieval? Yet it's not so popular. Is i... | [
0.0425419919192791,
-0.036346979439258575,
-0.04070191830396652,
-0.05009663850069046,
0.06442221999168396,
-0.06642427295446396,
0.045699622482061386,
0.02256331965327263,
0.05770628899335861,
-0.027990108355879784,
0.03718436881899834,
0.018872782588005066,
0.07701956480741501,
-0.022541... | |
63c869de-e8ab-5e51-ba1e-e3324573fa7a | /documentation/edge/edge-api/shard-lifecycle/ | Shard Lifecycle | Load an Existing Edge Shard | documentation | true | Shard Lifecycle > Load an Existing Edge Shard
Opens an Edge Shard from existing files at `path`.
```python
@staticmethod
def load(path: str, config: Optional[EdgeConfig] = None) -> EdgeShard
```
| Parameter | Description |
| --- | --- |
| `path` | Path to an existing shard directory. |
| `config` | Configuration ove... | [
0.02757624350488186,
-0.05327042192220688,
-0.03689415007829666,
-0.03058541938662529,
0.08001967519521713,
-0.04778669774532318,
0.046563856303691864,
0.02914607524871826,
0.06646309047937393,
-0.04273855686187744,
0.006129635032266378,
0.013797230087220669,
0.004406998865306377,
-0.03088... |
63c9a07e-6195-5450-bcdf-944195a17384 | /documentation/data-management/airbyte/ | Airbyte | documentation | false | Airbyte
[Airbyte](https://airbyte.com/) is an open-source data integration platform that helps you replicate your data
between different systems. It has a [growing list of connectors](https://docs.airbyte.io/integrations) that can
be used to ingest data from multiple sources. Building data pipelines is also crucial fo... | [
0.03267030790448189,
-0.01413649134337902,
-0.08084823936223984,
-0.06326452642679214,
0.08407433331012726,
0.018848588690161705,
0.039662476629018784,
0.006077202502638102,
0.04446161165833473,
-0.02372591756284237,
0.03778577968478203,
-0.021139908581972122,
0.04319128766655922,
-0.02167... | |
63d9d5a0-2a5a-5bee-810e-8d4e7cb691b0 | /documentation/tutorials-search-engineering/branch-aware-search/ | Branch-Aware Search | Step 6: Commit on the Root After the Fork | documentation | true | Branch-Aware Search > Step 6: Commit on the Root After the Fork
`root` keeps moving after `A` forked off. It updates `terms.md`, a file `A` inherited but never touched.
```text
root ●──●──●──────● root seq 3: update terms.md
└── A ●──● A forked at seq 2, so it should not see seq 3
```
`root` commits... | [
0.03975044563412666,
-0.07422786951065063,
-0.02290833741426468,
-0.029495885595679283,
0.04162723198533058,
-0.025055741891264915,
0.026848208159208298,
0.04703380912542343,
0.055976502597332,
-0.0554678849875927,
0.039632245898246765,
0.06079424172639847,
0.05415014922618866,
-0.03944196... |
63fa6cf0-b71d-539a-80f9-7234811fd80f | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Sparse Neural Retrieval > Beyond SPLADE | course | true | Demo: Keyword Search with Sparse Vectors > Sparse Neural Retrieval > Beyond SPLADE
SPLADE models are a strong choice for sparse neural retrieval, but they have limitations:
- **Token vs. word granularity.** SPLADE operates on **tokens** (subword pieces), which is less convenient for keyword‑oriented retrieval where u... | [
0.056740324944257736,
-0.05680195242166519,
-0.04441813752055168,
-0.06772056221961975,
0.05478793382644653,
-0.04743179306387901,
0.08595231175422668,
0.012870769016444683,
0.06240253150463104,
-0.017528623342514038,
0.015599621459841728,
0.009269152767956257,
0.045452363789081573,
0.0111... |
64086c72-3955-58bc-98f1-6799fa391b95 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Index | article | false | Why Vector Search Needs a Dedicated Database > Vector Index
[**Vector search**](/documentation/search/search/) relies on high-dimensional vector mathematics, making it computationally heavy at scale. A brute-force similarity search would require comparing a query against every vector in the database. In a database wit... | [
0.01732151210308075,
-0.05603514611721039,
-0.08897903561592102,
-0.02476184442639351,
0.04840786010026932,
-0.03423788771033287,
0.03295440971851349,
0.0012819071998819709,
0.08371672034263611,
-0.015470773912966251,
0.06159891188144684,
0.02422119490802288,
0.06958547979593277,
-0.021799... |
64113669-e97a-538a-af67-15e066b84c5f | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Qdrant Adds > SIMD Acceleration > 4-bit and 2-bit: scalar-quantized codebook + maddubs loop | article | false | TurboQuant in Qdrant > What Qdrant Adds > SIMD Acceleration > 4-bit and 2-bit: scalar-quantized codebook + maddubs loop
Two ideas combine to make the 4-bit and 2-bit kernels fast:
1. **The codebook is scalar-quantized to 8-bit integers.** The Lloyd-Max codebook (16 centroids for 4-bit, 4 for 2-bit) is mapped to a sin... | [
0.05990435555577278,
-0.042635686695575714,
-0.07484663277864456,
-0.027602437883615494,
0.06709905713796616,
-0.011817475780844688,
0.03258542716503143,
0.029138406738638878,
0.08703070878982544,
0.0016550793079659343,
0.035485461354255676,
-0.009337220340967178,
0.04239556938409805,
-0.0... |
64179196-bb2b-52ef-9351-ff7c0a93bab2 | /course/multi-vector-search/ | Multi-Vector Search Course | Time commitment | course | false | Multi-Vector Search Course > Time commitment
- Duration: 4 modules at 1 hour/module
- Video learning: 1.5 hours
- Hands-on notebooks: 1.5 hours
- Final project: 1-3 hours
- Total: 4-6 hours
**What you'll get**
- Build production-ready multi-vector pipelines
- Practice with real Colab notebooks
- Learn optimization te... | [
-0.005022876895964146,
-0.031617652624845505,
-0.04319038987159729,
-0.032504141330718994,
0.07285232096910477,
0.0051529803313314915,
0.03945618495345116,
0.052684321999549866,
0.10476376861333847,
-0.03632792457938194,
0.020700909197330475,
0.010567223653197289,
0.05448143929243088,
-0.0... |
6422e9d8-2e8b-5580-8558-a77919c50874 | /documentation/frameworks/semantic-router/ | Semantic-Router | documentation | true | Semantic-Router
[Semantic-Router](https://www.aurelio.ai/semantic-router/) is a library to build decision-making layers for your LLMs and agents. It uses vector embeddings to make tool-use decisions rather than LLM generations, routing our requests using semantic meaning.
Qdrant is available as a supported index in S... | [
0.023126553744077682,
-0.06542489677667618,
-0.03715447336435318,
-0.021829010918736458,
0.02264639176428318,
-0.012182449921965599,
0.09719771146774292,
0.06857910007238388,
0.038438666611909866,
-0.013112531043589115,
0.012551384046673775,
0.008952145464718342,
0.030867671594023705,
-0.0... | |
6434e1ee-6807-5dd9-8543-6dfeac1fbc2e | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-3/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives
*This is Part 3 of a 5-part tutorial on fine-tuning sparse embeddings for e-commerce search. In [Part 2](/documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-2/), we trained a SPLADE model on Modal. Now ... | [
0.06942091882228851,
-0.05812776833772659,
-0.042065128684043884,
-0.04685228317975998,
0.04489534720778465,
-0.03501307591795921,
0.0691043958067894,
0.017641672864556313,
0.059151098132133484,
-0.010894229635596275,
0.00876101478934288,
0.013820352032780647,
0.0612596794962883,
-0.051765... | |
64373f3b-ac61-54d0-908e-76ee57a9902d | /documentation/overview/vector-search/ | Understanding Vector Search in Qdrant | documentation | false | Understanding Vector Search in Qdrant
If you are still trying to figure out how vector search works, please read ahead. This document describes how vector search is used, covers Qdrant's place in the larger ecosystem, and outlines how you can use Qdrant to augment your existing projects.
For those who want to start w... | [
0.023540083318948746,
-0.06740860641002655,
-0.04307792708277702,
-0.009758609347045422,
0.06320537626743317,
-0.034283868968486786,
0.033480122685432434,
0.04030333459377289,
0.10634468495845795,
-0.0006998267490416765,
0.023722810670733452,
0.010102919302880764,
0.04497436061501503,
-0.0... | |
64401bb8-d125-5d51-97f8-a46f7e5ae900 | /documentation/embeddings/openai/ | OpenAI | Embed Documents | documentation | true | OpenAI > Embed Documents
One request embeds a list of inputs. Each item in the response carries the `index` of its input, which this example uses as the point ID:
```python
documents = [
"Qdrant is a vector search engine.",
"OpenAI embedding models turn text into dense vectors.",
]
response = openai_client.e... | [
0.03323943912982941,
-0.03945158049464226,
-0.031603049486875534,
-0.059419896453619,
0.078262560069561,
-0.04104910045862198,
0.05304161459207535,
0.1198781207203865,
0.08371935039758682,
-0.028167512267827988,
0.04009417071938515,
0.04267637059092522,
0.026844507083296776,
-0.05143114551... |
644563b4-27bb-5a49-834e-6cd83fc5a679 | /course/beginners/module-2/core-data-model/ | Core Data Model | Inserting a Point | course | true | Core Data Model > Inserting a Point
Each point contains an ID, a vector that represents your content, and a payload with metadata you can use to filter or return results later.
Use `upsert` to add a point to a collection. If the ID is new, Qdrant inserts the point. If the ID already exists, Qdrant updates the existin... | [
0.027858365327119827,
-0.021408960223197937,
-0.018213501200079918,
-0.02181081846356392,
0.035477325320243835,
-0.012118634767830372,
0.08615836501121521,
0.07135498523712158,
0.07676773518323898,
-0.00436363322660327,
0.013612119480967522,
0.014075120911002159,
0.041371289640665054,
0.01... |
644ba3f4-1eff-58c9-a573-0dd1d4419866 | /articles/what-is-a-vector-database/ | What is a Vector Database? | The Architecture of a Vector Database > SDKs | article | false | What is a Vector Database? > The Architecture of a Vector Database > SDKs
Qdrant offers a range of SDKs. You can use the programming language you're most comfortable with, whether you're coding in [Python](https://github.com/qdrant/qdrant-client), [Go](https://github.com/qdrant/go-client), [Rust](https://github.com/qd... | [
0.01341149304062128,
-0.037468697875738144,
-0.014178658835589886,
-0.021223213523626328,
0.033332109451293945,
-0.043461378663778305,
0.09346845746040344,
0.012584085576236248,
0.04886708781123161,
-0.03403769060969353,
0.04759453982114792,
0.024901723489165306,
0.06814746558666229,
-0.04... |
645559b0-0e48-5c50-a35b-ee89e47c9e41 | /documentation/tutorials-operations/gpu-accelerated-hnsw-indexing/ | GPU-Accelerated HNSW Indexing | GPU vs. CPU Comparison > Cost of Indexing | documentation | false | GPU-Accelerated HNSW Indexing > GPU vs. CPU Comparison > Cost of Indexing
A GPU cluster tends to cost more per hour than a CPU-only cluster with equivalent specs. Whether that's worth it depends on how much indexing you actually do with it, not on the hourly rate alone: a large enough speedup on indexing time can offs... | [
0.00119811634067446,
-0.01553727313876152,
-0.060571227222681046,
-0.02245292253792286,
0.05601018667221069,
0.012538916431367397,
0.024251742288470268,
0.03297353535890579,
0.08900516480207443,
-0.04673865810036659,
0.05965210124850273,
0.01960589922964573,
0.038419779390096664,
0.0063792... |
646b586f-b972-515f-8ad3-7260bdf5dbeb | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Security | documentation | false | Qdrant Fundamentals > Security
### Is my Qdrant cluster secure by default?
It depends on your deployment. Qdrant Cloud clusters are always secure by default. Self-hosted deployments are not: they're open to all network interfaces and have no authentication configured until you set it up. See [Security](/documentation... | [
0.030307788401842117,
-0.019090354442596436,
-0.04168505594134331,
-0.03743549436330795,
0.036087825894355774,
-0.06069822609424591,
0.07633289694786072,
0.06051366403698921,
0.058480605483055115,
-0.031222064048051834,
0.027058985084295273,
0.03455055505037308,
0.0534469336271286,
-0.0353... |
6482c7d2-fa65-5f74-b1fd-bb8b06bf2256 | /documentation/embeddings/nvidia/ | NVIDIA | documentation | false | NVIDIA
[NVIDIA](https://build.nvidia.com/explore/retrieval) provides Nemotron embedding models with separate passage and query modes. There are two ways to use them with Qdrant:
- Call the hosted NVIDIA API from your application and send the vectors to Qdrant. Most of this page covers this path.
- Run the model in a ... | [
0.02423631027340889,
-0.057414550334215164,
-0.03772367537021637,
-0.023930471390485764,
0.05656559392809868,
-0.0021380081307142973,
0.10580135136842728,
0.048888370394706726,
0.05984298139810562,
-0.008648106828331947,
0.0389220267534256,
-0.004728463012725115,
0.036718133836984634,
-0.0... | |
648c45b2-bceb-5a83-a6b3-14a3b73fa863 | /documentation/search-patterns/choose-embedding-model/ | How to Choose an Embedding Model: Evaluation & Tradeoffs | Evaluation: The Holy Grail of Vector Search > Building the Ground Truth Dataset | documentation | true | How to Choose an Embedding Model: Evaluation & Tradeoffs > Evaluation: The Holy Grail of Vector Search > Building the Ground Truth Dataset
The way your dataset will look depends on the task you want to evaluate. If we speak about semantic similarity,
then you will need pairs of texts with a score indicating how simila... | [
0.051902901381254196,
-0.050178635865449905,
-0.06377141177654266,
-0.02753596194088459,
0.05547870323061943,
-0.031077280640602112,
0.06478148698806763,
0.023344384506344795,
0.06409770995378494,
-0.02763163484632969,
0.04105706140398979,
-0.0017132675275206566,
0.0889894962310791,
-0.016... |
64a81b3e-c384-573b-baa8-682435665a9b | /course/multi-vector-search/module-3/evaluating-pipelines/ | Evaluating Search Pipelines | Course Conclusion | course | false | Evaluating Search Pipelines > Course Conclusion
Congratulations on completing the Multi-Vector Search course!
You've journeyed from the foundations of late interaction and MaxSim distance, through multi-modal applications with ColPali, to production optimization techniques. You now have the knowledge to:
- **Underst... | [
0.02415199764072895,
-0.049661021679639816,
-0.02571781352162361,
-0.043714024126529694,
0.061756640672683716,
-0.02454998716711998,
0.06630796939134598,
0.04065369442105293,
0.04846593737602234,
-0.033176179975271225,
-0.011958518996834755,
0.034368596971035004,
0.048011038452386856,
-0.0... |
64c3d78c-e779-5e5f-8ddc-c09721794d5f | /documentation/search/text-search/text-filtering/ | Text Filtering | Full-Text Filtering | documentation | false | Text Filtering > Full-Text Filtering
In contrast to keyword filtering, filtering on text strings enables you to filter on individual words within a larger text field in a case-insensitive manner. To understand how this works, it's important to understand how text strings are processed at index time and query time. | [
0.02538888342678547,
-0.03102644719183445,
-0.03950665891170502,
-0.04479655250906944,
0.04100865498185158,
0.013281154446303844,
0.03719776123762131,
0.0413503423333168,
0.0644509568810463,
-0.01210896484553814,
0.027601009234786034,
0.040325015783309937,
0.07119888812303543,
0.0006814118... |
64cbd45c-161d-5c10-8dcb-621bf66ddb36 | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | Step 9: Filtering Without Payload Indexes | course | true | Demo: HNSW Performance Tuning > Step 9: Filtering Without Payload Indexes
Now, let's test filtering performance without indexes. This forces Qdrant to scan through vectors and check each one against the filter:
```python
print("Testing filtering without payload indexes")
# Warning: We enable unindexed_filtering_retr... | [
0.05608905851840973,
-0.03712432458996773,
-0.038390856236219406,
-0.03559299185872078,
0.018602509051561356,
-0.007639029063284397,
0.052967362105846405,
0.017837345600128174,
0.08851099759340286,
-0.015836330130696297,
0.029529791325330734,
0.07165472209453583,
0.056185152381658554,
-0.0... |
6509d770-a389-5c57-9643-7fb3876e1097 | /articles/what-is-a-vector-database/ | What is a Vector Database? | An Introduction to Vector Databases | article | false | What is a Vector Database? > An Introduction to Vector Databases
Most of the millions of terabytes of data we generate each day is **unstructured**. Think of the meal photos you snap, the PDFs shared at work, or the podcasts you save but may never listen to. None of it fits neatly into rows and columns.
Unstructured ... | [
0.017628133296966553,
-0.032250262796878815,
-0.08927323669195175,
-0.06342706084251404,
0.05020561069250107,
-0.02107909694314003,
0.05005837231874466,
0.03278464078903198,
0.08802416175603867,
0.009931866079568863,
0.022200845181941986,
0.012701413594186306,
0.06191283091902733,
-0.01913... |
651412ae-e45d-54e2-9c45-9d123879ead9 | /documentation/hybrid-cloud/platform-deployment-options/ | Deployment Platforms | Generic Kubernetes Support (on-premises, cloud, edge) | documentation | false | Deployment Platforms > Generic Kubernetes Support (on-premises, cloud, edge)
Qdrant Hybrid Cloud works with any Kubernetes cluster that meets the [standard compliance](https://www.cncf.io/training/certification/software-conformance/) requirements.
This includes for example:
- [VMWare Tanzu](https://tanzu.vmware.com/... | [
0.026215098798274994,
-0.03202986717224121,
-0.0474066436290741,
-0.054980020970106125,
0.0420125350356102,
-0.039106711745262146,
0.07554372400045395,
0.03142595291137695,
0.04915546625852585,
-0.037436190992593765,
0.01124519295990467,
-0.0048350621946156025,
0.026026664301753044,
-0.008... |
653e24a6-1c94-5c4e-8d87-72a4a547c278 | /course/multi-vector-search/module-3/quantization-techniques/ | Vector Quantization Techniques | The Memory Challenge with Multi-Vector Models | course | false | Vector Quantization Techniques > The Memory Challenge with Multi-Vector Models
By default, embedding models produce vectors with **float32 precision** - each component uses 32 bits (4 bytes) of memory. For single-vector embeddings, this is manageable. But multi-vector models like **ColModernVBERT** change the equation... | [
0.04958120360970497,
-0.041625406593084335,
-0.03760923445224762,
-0.0602029450237751,
0.07087917625904083,
-0.003145652823150158,
0.05306888371706009,
0.04992358013987541,
0.10940637439489365,
-0.007583559025079012,
0.011526431888341904,
-0.020278198644518852,
0.04402514547109604,
-0.0381... |
6540b9fa-c7c8-5ca1-8052-7ee2ded16bdf | /course/multi-vector-search/module-1/problems-multi-vector/ | Problems of Multi-Vector Search | course | false | Problems of Multi-Vector Search
Module 1
Multi-vector search delivers impressive retrieval quality, but it comes with significant challenges. Before deploying multi-vector search in production, you need to understand these limitations and plan accordingly.
The good news: Module 3 covers optimization techniques that ... | [
0.0007924295496195555,
-0.07873095571994781,
-0.06634765863418579,
-0.06050713732838631,
0.08749422430992126,
-0.03041277825832367,
0.03570754826068878,
0.03246958926320076,
0.08832085132598877,
0.006386966910213232,
0.01575797237455845,
0.052069224417209625,
0.034454699605703354,
-0.03686... | |
6545c893-aae7-5ef2-ac5e-1ed08f7a4e3b | /course/beginners/module-2/core-data-model/ | Core Data Model | Payload | course | false | Core Data Model > Payload
Custom JSON metadata attached to a point. Used for filtering, retrieval scoping, and result enrichment. Can hold strings, numbers, booleans, geo coordinates, or arrays. | [
0.0022694049403071404,
-0.005682977382093668,
-0.012444444000720978,
-0.04595455527305603,
0.03371134027838707,
-0.01976524293422699,
0.025768253952264786,
0.06024139001965523,
0.037950895726680756,
-0.03261898458003998,
0.05366449058055878,
-0.02642630599439144,
0.0746835246682167,
0.0018... |
657710e8-b46e-5987-b0d5-744e6f00e795 | /documentation/scaling/horizontal-scaling/ | Horizontal Scaling | Replication | documentation | false | Horizontal Scaling > Replication
Qdrant allows you to replicate shards between nodes in the cluster, keeping several copies of a shard spread across the cluster. This ensures the availability of data in case of node failures, except if all replicas are lost.
![A three-node cluster with a collection with three shards ... | [
0.024103553965687752,
-0.02677423506975174,
-0.07694035768508911,
-0.01041954755783081,
0.09257976710796356,
-0.026879964396357536,
0.08276458084583282,
0.026773078367114067,
0.04792122170329094,
-0.03774726763367653,
0.017766380682587624,
0.012927721254527569,
0.028227517381310463,
-0.029... |
65799605-b817-5797-8dfe-23dde59f6452 | /documentation/ops-configuration/quotas/ | Resource Quotas | Configuring Quotas > Configuration Precedence | documentation | false | Resource Quotas > Configuring Quotas > Configuration Precedence
Quotas set through the API take precedence over the configuration file or environment variables.
Until the quota is set through the API anywhere in the cluster, Qdrant reads the configuration file on every start, so stopping a node, changing the setting,... | [
0.04122848063707352,
-0.051699426025152206,
-0.015163343399763107,
-0.06783109158277512,
0.04020630940794945,
-0.047484688460826874,
0.036676596850156784,
0.06891468912363052,
0.04504071921110153,
-0.029408713802695274,
0.028913086280226707,
0.0012371200136840343,
0.05449390783905983,
-0.0... |
65861983-db08-5280-ad66-067d3d8e9179 | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | Trying Out Gridstore | article | false | Introducing Gridstore: Qdrant's Custom Key-Value Store > Trying Out Gridstore
Gridstore represents a significant advancement in how Qdrant manages its **key-value storage** needs. It offers great performance and streamlined updates tailored specifically for our use case. We have managed to achieve faster, more reliabl... | [
0.019619669765233994,
-0.0392596535384655,
-0.02694990672171116,
-0.025500621646642685,
0.05343342199921608,
-0.030755607411265373,
0.05615777149796486,
0.027901433408260345,
0.06455667316913605,
-0.05497917905449867,
0.03202157840132713,
-0.012754617258906364,
0.04758172482252121,
-0.0150... |
65b5671d-dd94-5b80-91f7-4760f45df58c | /documentation/embeddings/voyage/ | Voyage AI | Setup | documentation | true | Voyage AI > Setup
Install the Voyage AI SDK and the Qdrant client:
- Python: `pip install voyageai qdrant-client`
- TypeScript: `npm install voyageai @qdrant/js-client-rest`
Create both clients and a collection sized for the model. The Voyage AI client reads your API key from the `VOYAGE_API_KEY` environment variabl... | [
0.031770024448633194,
-0.03795185312628746,
-0.01806594617664814,
-0.0392286442220211,
0.04142597317695618,
-0.044838547706604004,
0.06020016223192215,
0.03554319590330124,
0.039469197392463684,
-0.03949209302663803,
0.02313603088259697,
0.029028182849287987,
0.06671801209449768,
-0.016915... |
65bc7388-de56-57d7-90e6-d1312733e275 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Training miniCOIL > Training Data | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Training miniCOIL > Training Data
We want miniCOIL vectors to be comparable according to a word's meaning — *fruit **bat*** and *vampire **bat*** should be closer to each other in low-dimensional vector space than to *baseball **bat***. So, we need something to... | [
0.043344609439373016,
-0.023336615413427353,
-0.062085263431072235,
-0.05495274439454079,
0.06083029881119728,
-0.04296190291643143,
0.04655152186751366,
0.030253520235419273,
0.037755828350782394,
-0.006429092027246952,
0.02210409753024578,
0.01935346983373165,
0.0840100422501564,
-0.0082... |
65c19c39-79e9-5388-8896-3996ed56b0c8 | /documentation/examples/rag-contract-management-stackit-cohere/ | Region-Specific Contract Management System | documentation | false | Region-Specific Contract Management System
| Time: 90 min | Level: Advanced | |
| --- | ----------- | ----------- |----------- |
Contract management benefits greatly from Retrieval Augmented Generation (RAG), streamlining the handling of lengthy business contract texts. With AI assistance, complex questions can be a... | [
0.03905075043439865,
-0.03391984850168228,
-0.06752871721982956,
-0.05178079009056091,
0.012861732393503189,
-0.0783778727054596,
0.05383317917585373,
0.0517730712890625,
0.06458812206983566,
-0.04169832542538643,
0.01134166307747364,
0.008362466469407082,
0.03392447903752327,
-0.056595578... | |
65cee207-dcdd-59fd-be5b-73358f0fc270 | /course/essentials/day-1/distance-metrics/ | Distance Metrics | Key Takeaways | course | false | Distance Metrics > Key Takeaways
1. **Check the Docs:** If you use a third-party embedding model, use the metric suggested in its documentation.
2. **The Safe Default:** If the documentation is unclear, pick **Cosine**. Qdrant normalizes vectors for Cosine collections, ensuring consistent ranking behavior.
3. **Cus... | [
0.03357405215501785,
-0.02881711721420288,
-0.03886488452553749,
-0.025676395744085312,
0.03639509528875351,
-0.01676149107515812,
0.05797429755330086,
0.06217864900827408,
0.0867467150092125,
-0.028853043913841248,
0.017551695927977562,
0.0031591628212481737,
0.03378571569919586,
-0.00822... |
65ddbcdb-68ec-5851-88f7-a9e9264332c8 | /documentation/private-cloud/changelog/ | Changelog | 1.9.13 (2026-07-30) | documentation | false | Changelog > 1.9.13 (2026-07-30)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.37.3 |
| operator | 2.34.2 |
| qdrant-cluster-manager | v0.3.19 |
| qdrant-cluster-exporter | 1.8.0 |
Latest validated Qdrant version: 1.18.3
* Updated operato... | [
0.04012278839945793,
-0.01268101017922163,
-0.06284341961145401,
-0.04324817657470703,
0.05635496973991394,
-0.04449642077088356,
0.06645425409078598,
0.03048296831548214,
0.045855164527893066,
-0.033325906842947006,
0.02736227586865425,
0.044221051037311554,
0.053716324269771576,
-0.06390... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.