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 |
|---|---|---|---|---|---|---|---|
890247a7-a529-5f80-9cd3-6d08fbb242a1 | /documentation/embeddings/bedrock/ | Amazon Bedrock | Next Steps | documentation | false | Amazon Bedrock > Next Steps
- [Use named vectors](/documentation/manage-data/vectors/#named-vectors) to keep Titan and Nova vectors on the same points.
- [Filter search results](/documentation/search/filtering/) by payload fields.
- [Combine Bedrock vectors with sparse vectors](/documentation/search/hybrid-queries/) f... | [
0.03321360796689987,
-0.02977059967815876,
-0.01771678403019905,
-0.00034191645681858063,
0.05043604224920273,
-0.03939308226108551,
0.051138050854206085,
-0.021846115589141846,
0.02562861517071724,
0.01007172279059887,
0.04517023265361786,
0.03322884067893028,
0.07102427631616592,
0.01670... |
8905a4ba-2bee-5699-b8a3-487e89b8990d | /course/essentials/day-7/tensorlake/ | Integrating with Tensorlake | Resources | course | false | Integrating with Tensorlake > Resources
- [TensorLake Qdrant Integration](https://docs.tensorlake.ai/integrations/qdrant#qdrant):
Official TensorLake documentation for integrating with Qdrant. Learn about document parsing, knowledge graph creation, and structured data extraction for enhanced RAG applications.
- [... | [
0.03679205849766731,
-0.05622173100709915,
-0.08111874759197235,
-0.011532546021044254,
0.06954983621835709,
-0.017933350056409836,
0.06875520944595337,
0.05155594274401665,
0.036608245223760605,
-0.023270679637789726,
-0.0010447446256875992,
0.021822921931743622,
0.06387722492218018,
-0.0... |
893ccea0-35ba-55ab-8a6b-6f7f692a48c5 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | documentation | false | Relevance Feedback Retrieval in Qdrant
| Time: 30 min | Level: Intermediate | Output: [GitHub](https://github.com/qdrant/examples/blob/master/using-relevance-feedback/Customizing_Relevance_Feedback.ipynb) | [](https://githubtocolab.com/qdrant/ex... | [
0.032296597957611084,
-0.022286344319581985,
-0.024866489693522453,
-0.06087452918291092,
0.0719006285071373,
-0.035561397671699524,
0.03625635430216789,
0.054852329194545746,
0.0712570920586586,
-0.02225351333618164,
0.02069331333041191,
0.01923348940908909,
0.09692896157503128,
-0.043398... | |
893f6818-0e0a-5c3d-b71f-74d7fbccd74f | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++
Finding enough time to study all the modern solutions while keeping your production running is rarely feasible.
Dense retrievers, hybrid retrievers, late interaction… How do they work, and where do they fit best?
If only we could compare retrievers as easily as p... | [
0.020068615674972534,
-0.02305886708199978,
-0.02158036082983017,
-0.05112691968679428,
0.0230970848351717,
-0.06322303414344788,
0.05244577303528786,
0.040444862097501755,
0.07078249752521515,
-0.011359390802681446,
0.004654083400964737,
0.05518979951739311,
0.04443396255373955,
-0.034153... | |
89434330-52bd-5663-b8a4-f94b6b1330fe | /course/beginners/module-5/clustering-risk-signals/ | Clustering Risk Signals | course | false | Clustering Risk Signals
Module 5
Clustering groups signals that describe the same underlying event, even when they arrive from different sources. A factory fire appears in a local news article, a captioned satellite image, and an earnings call answer. Because [Ingestion Pipeline](/course/beginners/module-5/ingestion-... | [
0.05342813953757286,
-0.023071104660630226,
-0.05487462505698204,
-0.07042616605758667,
0.07666060328483582,
-0.0285897608846426,
0.08157427608966827,
0.08592058718204498,
0.056457940489053726,
-0.039569176733493805,
0.023539191111922264,
0.03580480441451073,
0.023937329649925232,
-0.01908... | |
8951b5a7-cf68-594a-b0c9-c14a8be67d6b | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 2: Transactional Outbox Pattern > The Write Path | documentation | true | Keeping Postgres and Qdrant in Sync > Tier 2: Transactional Outbox Pattern > The Write Path
Every CRUD endpoint opens a single Postgres transaction that writes both the product and the outbox event:
```py
@router.post("/products", response_model=ProductResponse, status_code=201)
async def create_product(product: Prod... | [
0.02483009360730648,
-0.06761866807937622,
-0.028502658009529114,
-0.007710279431194067,
0.01833176612854004,
-0.03225646913051605,
0.05084720626473427,
0.052229009568691254,
0.07527483254671097,
0.007185823284089565,
0.03700195997953415,
0.028156360611319542,
0.06513531506061554,
-0.01112... |
895226b4-1a7e-5343-b2f2-57dc1b5099e4 | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 3: Gold-Standard Evaluation (When You Have Labeled Data) | documentation | false | Search Quality > Tier 3: Gold-Standard Evaluation (When You Have Labeled Data)
Tier 3 measures whether search results are *relevant*, not merely consistent with the source system. This requires labeled relevance judgments: for a set of queries, human-verified labels indicating which documents are relevant. | [
0.01711491122841835,
-0.054927192628383636,
-0.07072742283344269,
-0.053416747599840164,
0.04792053624987602,
0.0031380108557641506,
0.07143063843250275,
0.04863845556974411,
0.08707774430513382,
-0.02516862377524376,
0.007755547296255827,
0.01934734173119068,
0.070482037961483,
-0.0075225... |
89912fc6-205d-5937-9534-a889a337768c | /documentation/production-operations/predictable-search-latency/ | Configure Qdrant's Optimizer for Predictable Search Latency | Takeaways | documentation | false | Configure Qdrant's Optimizer for Predictable Search Latency > Takeaways
- Try the experimental `prevent_unoptimized` flag before a bulk load if a short delay before new points become searchable is acceptable, and switch writes to `wait=false` first if your client defaults to `wait=true`. Confirm current behavior again... | [
0.028999783098697662,
-0.04519839957356453,
-0.040093813091516495,
-0.022439483553171158,
0.06361033767461777,
-0.0465862974524498,
0.026415983214974403,
0.005813682451844215,
0.07089336961507797,
-0.034281641244888306,
0.04382270574569702,
0.02263530343770981,
0.07107388973236084,
-0.0394... |
899e6583-61a8-536a-a0db-336ec6f260ee | /documentation/observability/openlit/ | OpenLIT | documentation | true | OpenLIT
[OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native LLM Application Observability tool and includes OpenTelemetry auto-instrumentation to monitor Qdrant and provide insights to improve database operations and application performance.
This page assumes you're using `qdrant-client` version ... | [
0.02131943590939045,
-0.04190217703580856,
-0.04294104129076004,
-0.03970937430858612,
0.08767994493246078,
-0.016480376943945885,
0.07786372303962708,
0.08141428232192993,
0.01849733106791973,
-0.021200260147452354,
0.02765243873000145,
-0.014679739251732826,
0.014457665383815765,
-0.0322... | |
89a62335-7a16-5a63-96f0-8b42646729ce | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Migrate Using Named Vectors > Step 4: Switch Search to the New Vector | documentation | true | Migrate to a New Embedding Model > Migrate Using Named Vectors > Step 4: Switch Search to the New Vector
Before switching, check that no point is missing the new vector, then [compare retrieval quality](#check-retrieval-quality-before-switching) between the two vectors on your own queries. This count returns `0` when ... | [
0.057227764278650284,
-0.06937555223703384,
-0.015124857425689697,
-0.010458801873028278,
0.04433301091194153,
-0.004493115469813347,
0.05521813780069351,
0.010472415015101433,
0.05189685523509979,
-0.010760192759335041,
0.019957829266786575,
0.046981677412986755,
0.03336551412940025,
-0.0... |
89a625a7-7f7c-5540-8e9d-a6002b6832bf | /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
| Quantization | `rescore` | `nDCG@10` | `Recall@10` Against Exact |
|---|---|---|---|
| float32 | not applicable | 0.3103 | 0.957 |
| TurboQuant `bits4` | off | 0.3218 | 0.918 |
| TurboQuant `bits4` | on, `oversampling` 4 | 0.3238 | 0.993 |
| TurboQuant `bit... | [
0.032246123999357224,
-0.05658862739801407,
-0.025418613106012344,
-0.013930418528616428,
0.05978100374341011,
-0.0004479464842006564,
0.026733284816145897,
0.05023492872714996,
0.06858170032501221,
-0.019624903798103333,
0.045842692255973816,
0.012350176461040974,
0.054217275232076645,
-0... |
89b1be15-a441-5286-9217-5d7165a57b76 | /documentation/data-management/dlt/ | DLT | documentation | true | DLT
[DLT](https://dlthub.com/) is an open-source library that you can add to your Python scripts to load data from various and often messy data sources into well-structured, live datasets.
With the DLT-Qdrant integration, you can now select Qdrant as a DLT destination to load data into.
**DLT Enables**
- Automated ... | [
0.035771165043115616,
-0.04940304160118103,
-0.052366696298122406,
-0.01598709262907505,
0.04491165652871132,
0.0014726229710504413,
0.07335464656352997,
0.03805303946137428,
0.07238829880952835,
-0.040173307061195374,
0.026569698005914688,
-0.0003428304917179048,
0.040838226675987244,
-0.... | |
89cfe12e-95bf-5258-8d3c-88b8a3561e04 | /documentation/search/low-latency-search/ | Low-Latency Search | Query Indexed Data Only > indexed_only Search Parameter | documentation | false | Low-Latency Search > Query Indexed Data Only > indexed_only Search Parameter
*Available as of v1.7.0*
To restrict searches to indexed data and small segments below the indexing threshold, set the `indexed_only` [search parameter](/documentation/search/search/#search-api) to `true`. This ensures more consistent and lo... | [
0.05774623528122902,
-0.045041825622320175,
-0.043649185448884964,
-0.019516723230481148,
0.04090374335646629,
-0.021724503487348557,
0.0208979994058609,
0.023680759593844414,
0.0905863419175148,
-0.03266431763768196,
0.03728121891617775,
0.01806369051337242,
0.06840457022190094,
-0.033853... |
89dfd870-933b-5bb4-b71e-ecc1a7d58584 | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | documentation | false | What to Check Before Tuning a Qdrant Collection
Before you change a setting, decide what better retrieval means for your workload. The right document at rank one, more candidates for a reranker, lower latency, and a smaller memory footprint each favor different settings, so pick your goal first. If your labeled querie... | [
0.05238524079322815,
-0.07565317302942276,
-0.03914647549390793,
-0.022783953696489334,
0.032427430152893066,
-0.04777375981211662,
0.04357588291168213,
0.040576573461294174,
0.05390603467822075,
-0.04356687515974045,
0.0026330407708883286,
0.0450906977057457,
0.04379528760910034,
-0.05037... | |
89e106fd-f2dc-5451-8dc4-2f97108e0848 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantClusterScheduledSnapshotSpec | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantClusterScheduledSnapshotSpec
QdrantClusterScheduledSnapshotSpec defines the desired state of QdrantCluster
_Appears in:_
- [QdrantClusterScheduledSnapshot](#qdrantclusterscheduledsnapshot)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
|... | [
0.003994206432253122,
0.004815326537936926,
-0.016977393999695778,
-0.03652811050415039,
0.06981027126312256,
-0.03455498442053795,
0.030313992872834206,
0.07627925276756287,
0.0818471685051918,
-0.03506184741854668,
0.044943917542696,
-0.008399292826652527,
0.047663699835538864,
-0.035599... |
8a5fb658-5ee1-53ee-ab18-b058c564557b | /documentation/ops-optimization/optimizer/ | Optimizer | Prevent Reads from Large Unindexed Segments > Monitoring Deferred Points | documentation | false | Optimizer > Prevent Reads from Large Unindexed Segments > Monitoring Deferred Points
You can check the number of deferred points in a collection via the `update_queue` section in the response of the [collection info API](/documentation/manage-data/collections/#collection-info). The same information is also available i... | [
0.020628802478313446,
-0.003821645164862275,
-0.020606473088264465,
-0.033115506172180176,
0.05089332535862923,
-0.02521117962896824,
0.04269663617014885,
0.05270100384950638,
0.07941463589668274,
-0.02528979443013668,
0.02719219960272312,
0.026590760797262192,
0.019732680171728134,
-0.034... |
8a61f488-3948-58aa-a292-e06d0896ce8a | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > Ingress | documentation | false | API Reference > qdrant.io/v1 > Resource Types > Ingress
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `enabled` _boolean_ | Enabled specifies whether to enable ingress for the cluster or not. | | Optional: \{\} |
| `annotations` _o... | [
0.0600193627178669,
-0.05974804610013962,
-0.04916451498866081,
-0.017061814665794373,
0.049120254814624786,
-0.054516904056072235,
0.048824865370988846,
0.05329399183392525,
0.034378159791231155,
-0.006405750289559364,
0.036009762436151505,
0.0044554793275892735,
0.04504609480500221,
-0.0... |
8a6f97f6-22fb-5bc5-b51c-fffd4c8ef9ba | /documentation/manage-data/indexing/ | Indexing | Vector Index | documentation | true | Indexing > Vector Index
A vector index is a data structure built on vectors through a specific mathematical model.
Through the vector index, we can efficiently query several vectors similar to the target vector.
Qdrant currently only uses HNSW as a dense vector index.
[HNSW](https://arxiv.org/abs/1603.09320) (Hierar... | [
0.036709707230329514,
-0.03838503360748291,
-0.08445281535387039,
-0.011066680774092674,
0.031193017959594727,
-0.02974959835410118,
0.07930219918489456,
0.05137741193175316,
0.06726478040218353,
-0.026244068518280983,
0.024723326787352562,
0.025452738627791405,
0.05645189434289932,
-0.014... |
8a704c86-0858-5ddc-914c-6fe7ac5da855 | /documentation/manage-data/vectors/ | Vectors | Inference | documentation | true | Vectors > Inference
Instead of providing vectors explicitly when ingesting or querying data, Qdrant can also generate vectors using a process called [inference](/documentation/inference/). Inference is the process of creating vector embeddings from text, images, or other data types using a machine learning model.
You... | [
0.052985645830631256,
-0.05320635065436363,
-0.03010372817516327,
-0.08584475517272949,
0.04807950556278229,
-0.017197098582983017,
0.11721235513687134,
0.06254856288433075,
0.059282995760440826,
-0.01599089615046978,
0.03600141778588295,
0.021557670086622238,
0.052159249782562256,
-0.0267... |
8a72d1a1-2706-5389-8bd9-d3c7ebed8b00 | /documentation/scaling/consistency-guarantees/ | Consistency Guarantees | documentation | false | Consistency Guarantees
By default, Qdrant focuses on availability and maximum throughput of search operations, which is a preferable trade-off for most use cases. During normal operation, you can search and modify data from any peer in the cluster: reads use a partial fan-out strategy to optimize latency and availabil... | [
0.026203524321317673,
-0.0926147922873497,
-0.05834997817873955,
0.0020913882181048393,
0.07798627018928528,
-0.04077513515949249,
0.07819981873035431,
0.02390795573592186,
0.03904447704553604,
-0.01623881608247757,
0.03412795811891556,
0.0433446504175663,
0.053777482360601425,
-0.01170986... | |
8a7d61a0-885e-5572-a16f-0461a110e887 | /documentation/tutorials-basics/reranking-hybrid-search/ | Hybrid Search with Reranking | Implementation > Ingest Data | documentation | true | Hybrid Search with Reranking > Implementation > Ingest Data
Now you can load the sci-fi book descriptions from a CSV and insert them into the `hybrid-search` collection. With Cloud Inference, embeddings are computed server-side by wrapping the text in a `Document` object.
This code uses a helper function to stream an... | [
0.03831318020820618,
-0.022849692031741142,
-0.06754998117685318,
-0.09292706102132797,
0.09455037117004395,
-0.027178140357136726,
0.07260234653949738,
0.05669382959604263,
0.05424261465668678,
-0.004986286628991365,
0.010081915184855461,
0.011242675594985485,
0.0307766180485487,
-0.04097... |
8a91e418-53c8-54c1-9210-cccc9933b343 | /articles/predicting-weak-retrieval/ | Predicting Weak Retrieval Without an LLM | Acting on a Weak Retrieval | article | false | Predicting Weak Retrieval Without an LLM > Acting on a Weak Retrieval
What you escalate *to* is the easy choice: rerank, rewrite, decompose, relax a filter, or hand off to a person. The gate does not care which; the expensive decision is *whether*, and it makes that for free on every query. The one thing escalation ca... | [
0.04605076089501381,
-0.05473412573337555,
-0.054227519780397415,
-0.05001036822795868,
0.04669523239135742,
-0.015536048449575901,
-0.001105724135413766,
0.02064584195613861,
0.05322224646806717,
0.0036319559440016747,
-0.01272487360984087,
0.000981947174295783,
0.06548861414194107,
0.008... |
8a9ca5e5-0a2f-5a5d-ba46-1f0f1dd59b4b | /documentation/scaling/horizontal-scaling/ | Horizontal Scaling | How Many Qdrant Nodes Should I Run? | documentation | false | Horizontal Scaling > How Many Qdrant Nodes Should I Run?
The ideal number of Qdrant nodes depends on how much you value cost-saving, resilience, and performance/scalability in relation to each other. | [
0.02544146589934826,
0.0043994658626616,
-0.060330525040626526,
-0.03543974831700325,
0.020435819402337074,
-0.06119811162352562,
0.06364643573760986,
0.06854860484600067,
0.11976084113121033,
-0.013692074455320835,
0.040853168815374374,
-0.0031199816148728132,
0.05164017155766487,
-0.0240... |
8aa220a3-08db-5391-9cd4-87363b3210af | /documentation/search-patterns/choose-embedding-model/ | How to Choose an Embedding Model: Evaluation & Tradeoffs | Evaluation: The Holy Grail of Vector Search > Know the Language Your Model Speaks | documentation | false | How to Choose an Embedding Model: Evaluation & Tradeoffs > Evaluation: The Holy Grail of Vector Search > Know the Language Your Model Speaks
Embedding models are trained with specific languages in mind. When evaluating one, consider whether it supports all the languages you have or predict to have in your data. If you... | [
0.049646589905023575,
-0.04066808521747589,
-0.026450838893651962,
-0.03472747653722763,
0.05717642605304718,
-0.03889334574341774,
0.09032254666090012,
0.039326101541519165,
0.025683166459202766,
-0.0036677538882941008,
-0.004733506590127945,
0.0271439291536808,
0.06105320155620575,
-0.03... |
8aa41191-ccc3-51db-9818-fabf87fb1026 | /documentation/scaling/node-failure-recovery/ | Node Failure Recovery | Consensus Checkpointing | documentation | true | Node Failure Recovery > Consensus Checkpointing
A cluster uses [Raft consensus](/documentation/scaling/horizontal-scaling/#raft-consensus) to manage cluster metadata and ensure that all nodes have a consistent view of the cluster state. Qdrant keeps a Raft log of operations that have modified the cluster state. When a... | [
0.049152541905641556,
-0.04052172973752022,
-0.03438612073659897,
-0.042333804070949554,
0.033258575946092606,
-0.023710496723651886,
0.08026620745658875,
0.0421425998210907,
0.02913101762533188,
-0.04428036883473396,
0.06641291081905365,
0.005721066612750292,
0.019568946212530136,
-0.0171... |
8ab1b58b-bdde-504b-9974-45b248266d65 | /course/essentials/day-6/ | Day 6: Final Project - Building a Production-Grade Search Engine | course | false | Day 6: Final Project - Building a Production-Grade Search Engine
Day 6
Ship a portfolio-ready vector search application that demonstrates everything you've learned. Build a sophisticated documentation search engine using hybrid retrieval, multivector reranking, and production-quality evaluation.
---
## Today's path... | [
0.0232075322419405,
-0.03558836132287979,
-0.044965680688619614,
-0.02705254778265953,
0.08020813018083572,
-0.03845788910984993,
0.03290219604969025,
0.023759737610816956,
0.08129393309354782,
-0.022324081510305405,
0.0040832869708538055,
0.0480191707611084,
0.06841599196195602,
-0.059188... | |
8abbaf83-d5e5-57b1-8f28-d1eaf47ff21c | /articles/neural-search-tutorial/ | Neural Search 101: A Complete Guide and Step-by-Step Tutorial | Step-by-step neural search tutorial using Qdrant > Step 5: Deploy as a service | article | true | Neural Search 101: A Complete Guide and Step-by-Step Tutorial > Step-by-step neural search tutorial using Qdrant > Step 5: Deploy as a service
To build the service we will use the FastAPI framework.
It is super easy to use and requires minimal code writing.
To install it, use the command
```bash
pip install fastapi ... | [
0.024424655362963676,
-0.06252285093069077,
-0.053541623055934906,
-0.007121914532035589,
0.04972226172685623,
-0.043819859623909,
0.06087333336472511,
0.0628088042140007,
0.047294169664382935,
-0.006322277709841728,
0.039269689470529556,
0.04584359750151634,
0.05312934145331383,
-0.056605... |
8adf5df7-e470-5356-823a-2344e8aa544b | /documentation/hybrid-cloud/hybrid-cloud-setup/ | Setup Hybrid Cloud | Advanced configuration > Mirroring images and charts > Required artifacts > Manual replication | documentation | true | Setup Hybrid Cloud > Advanced configuration > Mirroring images and charts > Required artifacts > Manual replication
This example uses Skopeo.
You can find your personal credentials for the Qdrant Cloud registry in the onboarding command, or you can fetch them with `kubectl`:
```shell
kubectl get secrets qdrant-regis... | [
0.03330359607934952,
-0.022349298000335693,
-0.02474389784038067,
-0.05541852489113808,
0.06410282105207443,
-0.042010873556137085,
0.07993770390748978,
0.0628284215927124,
0.030474485829472542,
-0.0691647157073021,
0.020804796367883682,
-0.008696301840245724,
0.11831595003604889,
-0.05989... |
8af264ff-e65d-5569-8566-2a776f4d1ab1 | /documentation/examples/rag-chatbot-red-hat-openshift-haystack/ | Private Chatbot for Interactive Learning | Implementation > Indexing pipeline > Test the entire pipeline | documentation | true | Private Chatbot for Interactive Learning > Implementation > Indexing pipeline > Test the entire pipeline
We can finally run it on the chunks to index the content in Qdrant:
```python
indexing_pipeline.run(data={"embedder": {"documents": chunks}})
```
The execution might take a while, as the model needs to process al... | [
0.003866409882903099,
-0.02610832080245018,
-0.04778434708714485,
-0.022226637229323387,
0.044097818434238434,
-0.03529307246208191,
0.04327508807182312,
0.032646968960762024,
0.05708407983183861,
-0.03793612867593765,
0.02312898263335228,
0.021477969363331795,
0.060842160135507584,
-0.052... |
8b110ff8-d04b-52ef-8a00-33bd98c450bb | /documentation/manage-data/collections/ | Collections | Create a Collection > Collection with Sparse Vectors | documentation | true | Collections > Create a Collection > Collection with Sparse Vectors
*Available as of v1.7.0*
Qdrant supports sparse vectors as a first-class citizen.
Sparse vectors are useful for text search, where each word is represented as a separate dimension.
Collections can contain sparse vectors as additional [named vectors]... | [
0.056469883769750595,
-0.06460796296596527,
0.0006502940668724477,
-0.02591802179813385,
0.05874358490109444,
-0.06368713825941086,
0.06584160029888153,
0.04942541569471359,
0.07896935194730759,
-0.06040626019239426,
0.01560123823583126,
0.06245742365717888,
0.017367782071232796,
-0.011261... |
8b3bea25-446f-5f8f-82a1-1413569c73cd | /documentation/edge/edge-api/reading-data/ | Reading Data | documentation | false | Reading Data
An Edge Shard offers several ways to read data. `query` is the similarity search entry point, supporting prefetches, fusion, and reranking. `scroll` pages through points without scoring them, and `retrieve`, `count`, and `facet` read points and payload statistics directly.
In Rust, query_groups and searc... | [
0.05160347744822502,
-0.03436267003417015,
-0.0740225538611412,
-0.028973283246159554,
0.04978448897600174,
-0.041958898305892944,
0.07201521098613739,
0.03899187222123146,
0.045884229242801666,
-0.008938000537455082,
0.05890164524316788,
0.016639094799757004,
0.03852175176143646,
0.022660... | |
8b42f3cf-0560-5927-baad-02cfbcbabbb9 | /course/ | Qdrant Academy | Learn to Build, Scale, and Master AI-Native Search | course | false | Qdrant Academy > Learn to Build, Scale, and Master AI-Native Search
Qdrant Academy is your step-by-step learning hub for mastering vector search, hybrid retrieval, and real-world AI applications with structured, free, online courses.
Whether you’re new to Qdrant or building production-grade systems, our guided course... | [
0.041328445076942444,
-0.022950297221541405,
-0.06397916376590729,
-0.026385502889752388,
0.04621636122465134,
-0.028312398120760918,
0.06182583048939705,
0.048567745834589005,
0.06633906811475754,
-0.03077828325331211,
0.052759964019060135,
0.007173263933509588,
0.06425737589597702,
-0.03... |
8b5e25bd-05a2-568a-ba1e-32cf175ae366 | /documentation/frameworks/langchain/ | LangChain | Next steps | documentation | false | LangChain > Next steps
If you'd like to know more about running Qdrant in a LangChain-based application, please read our article
[Question Answering with LangChain and Qdrant](/documentation/tutorials-build-essentials/question-answering-langchain/). Some more information
might also be found in the [LangChain documenta... | [
0.02010062150657177,
-0.05407550558447838,
-0.04707721620798111,
-0.04735899344086647,
0.01924446038901806,
-0.06989552825689316,
0.04760719835758209,
0.011803011409938335,
0.05866624787449837,
-0.02179439552128315,
0.018225474283099174,
-0.005663321353495121,
0.0848325788974762,
-0.029353... |
8b66a8eb-5e62-589d-b5c9-8e43f250c4d6 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > ScheduledSnapshotPhase | documentation | false | API Reference > qdrant.io/v1 > Resource Types > ScheduledSnapshotPhase
_Underlying type:_ _string_
_Appears in:_
- [QdrantClusterScheduledSnapshotStatus](#qdrantclusterscheduledsnapshotstatus)
| Field | Description |
| --- | --- |
| `Active` | |
| `Disabled` | | | [
0.011392285116016865,
-0.0344892218708992,
0.007058446761220694,
-0.06184759736061096,
0.06068917363882065,
-0.03567596897482872,
0.018331849947571754,
0.040517766028642654,
0.07768818736076355,
-0.04033562168478966,
0.06355038285255432,
-0.029388058930635452,
0.04597117379307747,
-0.03819... |
8b69d6cd-ec52-5932-a7c2-d84bd58151be | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search Beyond RAG > Recommendations | article | false | Why Vector Search Needs a Dedicated Database > Vector Search Beyond RAG > Recommendations
Vector search is perfect for [**recommendations**](/documentation/search/explore/#recommendation-api). Imagine browsing for a new book or movie. Instead of searching for an exact match, you might look for stories that capture a c... | [
0.0045330096036195755,
-0.05370836704969406,
-0.07508499175310135,
-0.02998577244579792,
0.06358814239501953,
-0.018944688141345978,
0.04694583639502525,
0.018907297402620316,
0.06173797324299812,
-0.005493622738867998,
0.025710182264447212,
0.06402861326932907,
0.09227868914604187,
-0.041... |
8b6b40d6-5a9b-5495-84dc-25ec7e46aa5c | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Key Takeaways > Why is this Approach Useful? | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Key Takeaways > Why is this Approach Useful?
This approach to training sparse neural retrievers:
1. Doesn’t rely on a relevance objective because it is trained in a self-supervised way, so it doesn’t need labeled datasets to scale.
2. Builds on the proven BM25... | [
0.019439488649368286,
-0.05450787767767906,
-0.010440865531563759,
-0.04321607947349548,
0.0689375028014183,
-0.05971923843026161,
0.06393597275018692,
0.04209621250629425,
0.04532179981470108,
-0.011278294026851654,
-0.012166657485067844,
0.04114547744393349,
0.07619202136993408,
0.003255... |
8b6c0141-b13c-54b5-b52f-7dacf09cb4e0 | /documentation/private-cloud/changelog/ | Changelog | 1.6.1 (2025-03-14) | documentation | false | Changelog > 1.6.1 (2025-03-14)
| Component | Version |
|------------------------|---------|
| qdrant-kubernetes-api | v1.14.2 |
| operator | 2.3.2 |
| qdrant-cluster-manager | v0.3.3 |
* Add support for GPU instances
* Experimental support for automatic shard balancing | [
0.03277556225657463,
-0.042834822088479996,
-0.05732081085443497,
-0.013648178428411484,
0.05714002624154091,
-0.03871510922908783,
0.05727463215589523,
0.04578325152397156,
0.05720204859972,
-0.044412460178136826,
0.040987588465213776,
0.023079078644514084,
0.0537438690662384,
-0.05342699... |
8b7be9fa-53dc-50ed-8293-b59205648b48 | /documentation/search-precision/automate-filtering-with-llms/ | LLM-Powered Filter Automation | Few notes on Qdrant filters | documentation | true | LLM-Powered Filter Automation > Few notes on Qdrant filters
Qdrant Python SDK defines the models using [Pydantic](https://docs.pydantic.dev/latest/). This library is de facto
standard for data validation and serialization in Python. It allows you to define the structure of your data using
Python type hints. For exampl... | [
0.06135396286845207,
-0.02559991367161274,
-0.04298519715666771,
-0.03519279882311821,
0.004127988591790199,
-0.03828565031290054,
0.09328701347112656,
0.06103048846125603,
0.0830346941947937,
-0.012284650467336178,
0.038346175104379654,
0.027590319514274597,
0.09683345258235931,
-0.025303... |
8b990ec2-ea21-57af-8695-ee9f833776bc | /documentation/quickstart/ | Local Quickstart | Download and run | documentation | true | Local Quickstart > Download and run
First, download the latest Qdrant image from Dockerhub:
```bash
docker pull qdrant/qdrant
```
Then, run the service:
```bash
docker run -p 6333:6333 -p 6334:6334 \
-v "$(pwd)/qdrant_storage:/qdrant/storage:z" \
qdrant/qdrant
```
On Windows, you may need to create a named... | [
0.015421750023961067,
-0.04243369773030281,
-0.026055166497826576,
-0.0023814726155251265,
0.033499330282211304,
-0.04418593645095825,
0.05454764887690544,
0.04053651541471481,
0.0744999572634697,
-0.029570844024419785,
0.04143697768449783,
0.011459738947451115,
0.06995108723640442,
-0.054... |
8bbf1188-f840-579b-84e0-fcb5d7f2d19c | /documentation/private-cloud/changelog/ | Changelog | 1.7.0 (2025-05-14) | documentation | false | Changelog > 1.7.0 (2025-05-14)
| Component | Version |
|------------------------|---------|
| qdrant-kubernetes-api | v1.16.3 |
| operator | 2.4.2 |
| qdrant-cluster-manager | v0.3.5 |
* Add optional automatic shard balancing
* Set strict mode by default for new clusters to only allow q... | [
0.044847823679447174,
-0.022475387901067734,
-0.0737668052315712,
-0.008400343358516693,
0.06528914719820023,
-0.0463951975107193,
0.04664753004908562,
0.04845823720097542,
0.0567949078977108,
-0.0394827276468277,
0.023995080962777138,
0.03385479748249054,
0.0467730350792408,
-0.0521949082... |
8bc6f3ca-ac5f-5670-a65b-fce7e2dde973 | /course/essentials/day-5/universal-query-demo/ | Demo: Universal Query for Hybrid Retrieval | Step 2: The Universal Query in Action > Prepare Query Embeddings | course | true | Demo: Universal Query for Hybrid Retrieval > Step 2: The Universal Query in Action > Prepare Query Embeddings
First, we encode our research query using all three embedding models:
```python
research_query = "transformer architectures for multimodal learning"
research_query_dense = next(dense_model.query_embed(resear... | [
0.027577590197324753,
-0.01385527104139328,
-0.037985485047101974,
-0.04879138991236687,
0.058312561362981796,
-0.023040756583213806,
0.03703312948346138,
0.0768057182431221,
0.05367618054151535,
-0.008688164874911308,
0.04176665097475052,
0.041176408529281616,
0.07291936129331589,
-0.0275... |
8bd1423a-e0e0-52f8-8b25-5e238befb1ae | /documentation/cloud/create-cluster/ | Create a Cluster | Creating a Production-Ready Cluster | documentation | false | Create a Cluster > Creating a Production-Ready Cluster
To create a production-ready cluster, you need to ensure the following:
**High Availability**
Your cluster should have at least 3 nodes, and each collection should have a replication factor of at least 2. This ensures that is one node fails, or is restarted due ... | [
-0.01460797619074583,
-0.016242198646068573,
-0.07866508513689041,
-0.045419879257678986,
0.07384967803955078,
-0.03317814692854881,
0.030479134991765022,
0.023755155503749847,
0.04345730319619179,
-0.023423098027706146,
0.051789987832307816,
0.02842097543179989,
0.04859397932887077,
-0.04... |
8bd5c652-975f-57de-9ec3-43dd23375310 | /documentation/search-tuning/when-your-collection-outgrows-ram/ | When Your Collection Outgrows RAM | Rescoring Adds the Disk Read | documentation | false | When Your Collection Outgrows RAM > Rescoring Adds the Disk Read
The memory cap decides what those placements deliver. The same query took about 4 ms with the originals resident, and 43 ms when rescoring reread them under a 4 GiB limit.
| Limit | Original Vectors | Quantized Vectors | `rescore` | p50 ms | GB Read, Bo... | [
0.032120537012815475,
-0.03768907114863396,
-0.023931032046675682,
-0.01907339133322239,
0.07179968059062958,
-0.008253710344433784,
0.015049559064209461,
0.04069383442401886,
0.0960751473903656,
-0.01790839247405529,
0.041962552815675735,
0.014253837056457996,
0.0296526737511158,
0.003351... |
8bfbf8d9-06c9-5a7f-b36e-70661b5c897d | /documentation/frameworks/deepeval/ | DeepEval | documentation | false | DeepEval
[DeepEval](https://deepeval.com) by Confident AI is an open-source framework for testing large language model systems. Similar to Pytest but designed for LLM outputs, it evaluates metrics like G-Eval, hallucination, answer relevancy.
DeepEval can be integrated with Qdrant to evaluate RAG pipelines — ensuring... | [
0.05151856318116188,
-0.03236745670437813,
-0.035897430032491684,
-0.07608997076749802,
0.03913336619734764,
-0.03484553471207619,
0.14010170102119446,
0.06554016470909119,
0.02865583635866642,
-0.050652876496315,
0.014143010601401329,
0.003735476406291127,
0.03835144266486168,
-0.02535568... | |
8bff9265-618c-5761-a64b-234d8d767907 | /documentation/migrate-to-qdrant/from-weaviate/ | From Weaviate | Concept Mapping | documentation | false | From Weaviate > Concept Mapping
| Weaviate | Qdrant | Notes |
| :--- | :--- | :--- |
| Class | Collection | One-to-one mapping |
| Properties | Payload | Direct mapping |
| `cosine` | `Cosine` | Direct mapping |
| `l2-squared` | `Euclid` | Qdrant uses L2, not L2-squared; scores differ in magnitude but ranking is ident... | [
0.059924665838479996,
-0.03246472030878067,
-0.058046601712703705,
-0.07553619891405106,
0.056676510721445084,
-0.03870261088013649,
0.04383054003119469,
0.05396513268351555,
0.06458801031112671,
-0.0728771984577179,
0.012707812711596489,
0.015675075352191925,
0.025476915761828423,
0.01280... |
8c0c5c5f-cdc3-57c9-843c-e25dd63864a0 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | Conclusion | article | false | TurboQuant in Qdrant > Conclusion
TurboQuant gives Qdrant a new path on the compression ladder: 8x compression at SQ-level recall, and at 16x / 32x typically 9–24 percentage points of recall above BQ on every dataset we benchmarked. What makes that work is a hybrid: TurboQuant's MSE codebook and integer-arithmetic SIM... | [
0.04015694558620453,
-0.028022920712828636,
-0.0569366030395031,
-0.05006972327828407,
0.03279123455286026,
-0.0021529339719563723,
0.06070345640182495,
0.038541313260793686,
0.07495428621768951,
-0.05442462116479874,
0.037830132991075516,
0.020503798499703407,
0.05753744766116142,
-0.0535... |
8c1a8ccc-858d-5354-899b-8c7227d29c68 | /documentation/tutorials-build-essentials/data-ingestion-beginners/ | S3 Ingestion | Prerequisites | documentation | true | S3 Ingestion > Prerequisites
| Requirement | Details |
| --- | --- |
| S3 storage | An [AWS account](https://aws.amazon.com/free/) with access to S3 is recommended. It is not required: any S3-compatible service, such as MinIO or RustFS, works if you have its endpoint URL and an access key pair that can read and write ... | [
0.02023451216518879,
-0.021552152931690216,
-0.04738185554742813,
-0.023837437853217125,
0.022774040699005127,
-0.05705435201525688,
0.029688123613595963,
0.03861832991242409,
0.022002901881933212,
-0.018108030781149864,
0.01019324455410242,
0.03708323836326599,
0.0339948907494545,
-0.0306... |
8c202486-8111-5c89-b469-38b37a280e8d | /documentation/cloud/cluster-monitoring/ | Monitor Clusters | Grafana Dashboard | documentation | false | Monitor Clusters > Grafana Dashboard
If you scrape your Qdrant cluster system metrics into your own monitoring system, and you are using Grafana, you can use our [Grafana dashboard](https://github.com/qdrant/qdrant-cloud-grafana-dashboard) to visualize these metrics.
:
def __init__(self, retriever: VectorRetriever) -> None:
intents = discord.Intents.default()
intents.message_content = True
super().__init__(
intents=intents, allowed_mentions=dis... | [
-0.006686377804726362,
-0.0202786847949028,
-0.021081015467643738,
-0.0043401108123362064,
0.018370548263192177,
-0.05783601477742195,
0.024255910888314247,
0.030192233622074127,
0.021459504961967468,
0.0037358771078288555,
0.01298195868730545,
0.015490906313061714,
0.07485193014144897,
0.... |
8c9d6613-b388-5236-a0a3-4007ea25b1f3 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-3/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives | ANCE-inspired Hard Negative Mining | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives > ANCE-inspired Hard Negative Mining
The training in Part 2 used in-batch negatives: other products in the same batch serve as negatives for a given query. This works but has a limitation: random products are easy negatives. Th... | [
0.0334564633667469,
-0.06859361380338669,
-0.06053320690989494,
-0.06135690212249756,
0.06597249209880829,
-0.008228770457208157,
0.04132866486907005,
0.008770359680056572,
0.071881003677845,
-0.020685164257884026,
0.03371402993798256,
0.033710818737745285,
0.06376595050096512,
-0.04261320... |
8ca3c5db-971c-5451-bbc6-ac7a7c711a86 | /documentation/tutorials-operations/time-based-sharding/ | Time-Based Sharding | Pruning Shards | documentation | true | Time-Based Sharding > Pruning Shards
Every night at midnight, create a new shard for the new data that will be ingested that day. If you only query the last 7 days of data, you can also delete the oldest shard. You can automate this with a cron job. The example sets `today` to `2026-04-08` to match the sample data. In... | [
0.010630670003592968,
-0.0355101153254509,
-0.03221488744020462,
-0.039702318608760834,
0.056571077555418015,
-0.01939268410205841,
0.0006579295732080936,
0.032695598900318146,
0.06795910000801086,
-0.00817034486681223,
0.057193316519260406,
0.00004943127714795992,
0.058876946568489075,
-0... |
8cf90d3b-cf3e-5b2f-88e8-1794e8a32fcd | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Results > Benchmarking | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Results > Benchmarking
We can see miniCOIL performing slightly better than BM25 in four out of five tested domains. It shows that **we're moving in the right direction**.
To use any model for your specific use case, always benchmark it yourself! Performance on... | [
0.0181589275598526,
-0.024412695318460464,
-0.014099004678428173,
-0.029431307688355446,
0.04521750286221504,
-0.06764574348926544,
0.08009796589612961,
0.040352482348680496,
0.05960816890001297,
-0.021102070808410645,
0.015827400609850883,
0.02747633308172226,
0.05476457625627518,
-0.0075... |
8d12c679-ff30-5813-9f56-48fe32ec705d | /documentation/security/ | Security | Authentication > Table of Access | documentation | false | Security > Authentication > Table of Access
| Action | manage | read-only | collection read-write | collection read-only |
|--------|--------|-----------|----------------------|-----------------------|
| list collections | ✅ | ✅ | 🟡 | 🟡 |
| get collection info | ✅ | ✅ | ✅ | ✅ |
| create collection | ✅ | ❌ | ❌ | ❌ |
... | [
0.026313355192542076,
-0.01992010697722435,
-0.06630707532167435,
-0.002181696705520153,
0.0470428504049778,
-0.03573225438594818,
0.019108420237898827,
0.04591093957424164,
0.05470697954297066,
-0.04505570977926254,
0.060651905834674835,
0.04024842381477356,
0.030872495844960213,
-0.03001... |
8d20c481-fd92-5be8-a589-f82b8a987725 | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | Gridstore Architecture: Three Main Components > 3. The Gaps Layer for Effective Updates | article | false | Introducing Gridstore: Qdrant's Custom Key-Value Store > Gridstore Architecture: Three Main Components > 3. The Gaps Layer for Effective Updates
To further optimize update handling, Gridstore introduces **The Gaps Layer**, which provides a higher-level view of block availability.
Instead of scanning the entire bitmas... | [
0.005481741391122341,
-0.008308090269565582,
-0.04830442741513252,
-0.022211506962776184,
0.06348825246095657,
-0.040050383657217026,
0.03228291496634483,
0.029475804418325424,
0.06467794626951218,
-0.035411663353443146,
0.002504464238882065,
-0.0024846065789461136,
0.07960626482963562,
-0... |
8d35391f-1753-594d-891a-e80234a56236 | /documentation/capacity-planning/ | Capacity Planning | Cluster Topology > Node Count | documentation | true | Capacity Planning > Cluster Topology > Node Count
Start from the RAM total you calculated in [Calculating RAM and Disk Size](#calculating-ram-and-disk-size) and divide by the usable RAM per node, keeping each node under roughly 80% of its physical memory so the OS has room for page cache and temporary optimizer work:
... | [
0.011677384376525879,
-0.04974385350942612,
-0.03187142312526703,
-0.06091105192899704,
0.05464751645922661,
-0.03634718433022499,
0.04188348725438118,
0.052902936935424805,
0.12308883666992188,
-0.026051219552755356,
0.016566110774874687,
0.005581074859946966,
0.04137701541185379,
-0.0391... |
8d5a8fe5-1d47-549f-bf58-0eab36980592 | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | Create custom shards for a single collection | documentation | true | How to Implement Multitenancy and Custom Sharding in Qdrant > Create custom shards for a single collection
When creating a collection, you will need to configure user-defined sharding. This lets you control the shard placement of your data, so that operations can hit only the subset of shards they actually need. In bi... | [
-0.0012921348679810762,
-0.04214837774634361,
-0.057901639491319656,
-0.02942431904375553,
0.0627414658665657,
-0.06615249812602997,
0.07103288918733597,
0.09586378931999207,
0.051320631057024,
-0.03971816599369049,
0.0185869000852108,
0.05866227298974991,
0.05174065753817558,
-0.057950228... |
8d5dca4a-66a0-501d-8346-85e00dfa6ffc | /course/multi-vector-search/module-3/pooling-techniques/ | Pooling Techniques | course | false | Pooling Techniques
Module 3
While quantization reduces the size of each vector, pooling reduces the number of vectors per document. By intelligently combining token embeddings, you can achieve significant memory savings while preserving retrieval quality.
---
---
**Follow along in Colab:**
--- | [
0.02229040488600731,
-0.04612961411476135,
-0.022215548902750015,
-0.07183142006397247,
0.0647878423333168,
-0.032865386456251144,
0.07263839989900589,
0.06407660245895386,
0.10489749908447266,
-0.0072181979194283485,
0.021067161113023758,
0.01515987329185009,
0.029127858579158783,
0.00005... | |
8d6e5268-865c-5ba7-b5b0-a2381a695060 | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 3: Gold-Standard Evaluation (When You Have Labeled Data) > Computing Tier 3 Metrics | documentation | true | Search Quality > Tier 3: Gold-Standard Evaluation (When You Have Labeled Data) > Computing Tier 3 Metrics
With labeled data, compute standard information retrieval metrics:
```py
import numpy as np
def ndcg_at_k(retrieved_ids, relevance_map, k):
"""Normalized Discounted Cumulative Gain at k."""
dcg = 0.0
... | [
0.026177875697612762,
-0.028272757306694984,
-0.04621845483779907,
-0.054677896201610565,
0.07088849693536758,
-0.047936536371707916,
0.054522305727005005,
0.08238822966814041,
0.08916144073009491,
-0.036670804023742676,
0.018269483000040054,
0.011702293530106544,
0.08169198036193848,
-0.0... |
8d828b6a-4466-5f54-bf8a-5b24821c03eb | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Sharding > Moving Shards | documentation | true | Distributed Deployment > Sharding > Moving Shards
*Available as of v0.9.0*
Qdrant allows moving shards between nodes in the cluster and removing nodes from the cluster. This functionality unlocks the ability to dynamically scale the cluster size without downtime. It also allows you to upgrade or migrate nodes without... | [
0.02780853770673275,
-0.03470350429415703,
-0.05537979304790497,
-0.032258398830890656,
0.0528397262096405,
-0.02828907035291195,
0.054038193076848984,
0.029358617961406708,
0.08506651967763901,
-0.03730103746056557,
0.026564376428723335,
0.01773267611861229,
0.01272051502019167,
-0.031268... |
8d85a46e-d3fb-5520-97c0-0471249556dc | /documentation/tutorials-build-essentials/question-answering-langchain/ | Question Answering with LangChain and Qdrant | How to Implement Question Answering with LangChain and Qdrant > Step 2: Building the knowledge base | documentation | true | Question Answering with LangChain and Qdrant > How to Implement Question Answering with LangChain and Qdrant > Step 2: Building the knowledge base
We also need some facts from which the answers will be generated. There is plenty of public datasets available, and
[Natural Questions](https://ai.google.com/research/Natur... | [
0.044212061911821365,
-0.01966232620179653,
-0.0510648712515831,
-0.030356116592884064,
0.05017560347914696,
-0.04625113308429718,
0.060822322964668274,
0.024030694738030434,
0.052802979946136475,
-0.02193363383412361,
0.019652973860502243,
0.021165678277611732,
0.026469800621271133,
-0.04... |
8d8b7ba0-8987-511b-be1d-45497bf0d221 | /course/multi-vector-search/module-2/visual-interpretability/ | Visual Interpretability of ColPali | What's Next | course | false | Visual Interpretability of ColPali > What's Next
You've now learned one of ColPali's most powerful features: the ability to see exactly where the model focuses when matching queries to documents. This transparency helps you:
- Debug unexpected search results
- Build trust in your retrieval system
- Understand model b... | [
0.013740425929427147,
-0.04953928664326668,
-0.035158153623342514,
-0.03818158805370331,
0.07280838489532471,
-0.02922205813229084,
0.04313690587878227,
0.025950279086828232,
0.014169692061841488,
-0.025691263377666473,
0.018172787502408028,
0.00922311656177044,
0.06171450763940811,
-0.021... |
8d8fa77a-cc8b-5336-9c10-6511ab76f8d2 | /documentation/embeddings/openai/ | OpenAI | Reduce Vector Size | documentation | true | OpenAI > Reduce Vector Size
`text-embedding-3` models accept a `dimensions` parameter that shortens the vector with little loss in quality. Set the collection's `size` to the same value, and pass the same `dimensions` when you embed queries:
```python
response = openai_client.embeddings.create(
model="text-embedd... | [
0.059470776468515396,
-0.03137559816241264,
-0.007808423135429621,
-0.08714728057384491,
0.06000027060508728,
-0.00981446634978056,
0.040461186319589615,
0.0670384094119072,
0.05986618995666504,
-0.049980077892541885,
0.04868611693382263,
0.023360060527920723,
0.040594201534986496,
-0.0348... |
8d972bc4-cfdf-5abc-9fa6-7094b7b172fb | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > KubernetesPod | documentation | false | API Reference > qdrant.io/v1 > Resource Types > KubernetesPod
_Appears in:_
- [KubernetesStatefulSet](#kubernetesstatefulset)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `annotations` _object (keys:string, values:string)_ | Annotations specifies the annotations for the Pods. | | Option... | [
0.057137876749038696,
-0.04887859895825386,
-0.005987020209431648,
-0.05167208984494209,
0.05548563599586487,
-0.058199699968099594,
0.04078388586640358,
0.050806544721126556,
0.03591182082891464,
-0.04748363792896271,
0.00950748473405838,
0.004717469215393066,
0.04630379378795624,
-0.0196... |
8d9bc2d3-3002-572f-a2c4-d39148d44316 | /documentation/tutorials-operations/time-based-sharding/ | Time-Based Sharding | Query the Data | documentation | true | Time-Based Sharding > Query the Data
### Query Today's Data
Now you can run a semantic query on the posts. Setting the shard key selector to `2026-04-07` (assuming today is April 7th, 2026) limits the query to the shard that stores today's data:
```python
query_text = "coffee"
resp = client.query_points(
colle... | [
-0.0004216149391140789,
-0.00039321952499449253,
-0.013680972158908844,
-0.018188176676630974,
0.016999484971165657,
-0.058247245848178864,
0.0064149401150643826,
0.01564043201506138,
0.04922524094581604,
-0.026859724894165993,
0.014394288882613182,
0.03205837681889534,
0.058285344392061234,... |
8dc3a138-b2e6-5bb4-8812-0197e6c32802 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Additional resources | article | false | Understanding SPLADE and Sparse Vectors > Additional resources
For those who want to dive deeper, here are the top papers on the topic most of which have code available:
1. Problem Motivation: [Sparse Overcomplete Word Vector Representations](https://ar5iv.org/abs/1506.02004?utm_source=qdrant&utm_medium=website&utm_c... | [
0.06011500209569931,
-0.02141926996409893,
-0.03462987765669823,
-0.04326071962714195,
0.07233041524887085,
-0.02903815358877182,
0.058243196457624435,
0.025643669068813324,
0.07613283395767212,
-0.023156223818659782,
0.012916862033307552,
-0.0007480630301870406,
0.03093774802982807,
-0.02... |
8dce89f8-27fa-5326-a55c-782fd3e054e9 | /course/essentials/day-5/universal-query-demo/ | Demo: Universal Query for Hybrid Retrieval | Step 2: The Universal Query in Action > Execute the Universal Query with ColBERT Reranking | course | true | Demo: Universal Query for Hybrid Retrieval > Step 2: The Universal Query in Action > Execute the Universal Query with ColBERT Reranking
Finally, we send our complete query that ties everything together:
```python
# The Universal Query: Global filter propagates through all stages
response = client.query_points(
co... | [
0.041989754885435104,
-0.008764142170548439,
-0.05190448462963104,
-0.040339745581150055,
0.0793735608458519,
-0.03326357901096344,
0.03917793184518814,
0.045173488557338715,
0.08668416738510132,
-0.020693371072411537,
0.05322101339697838,
0.02652660198509693,
0.0761474147439003,
-0.025968... |
8ddd4468-d1de-58c1-a42b-dfdeaf356c69 | /documentation/search-patterns/choose-embedding-model/ | How to Choose an Embedding Model: Evaluation & Tradeoffs | Throughput, Latency, and Cost | documentation | false | How to Choose an Embedding Model: Evaluation & Tradeoffs > Throughput, Latency, and Cost
Even if you found the best performing embedding model for your domain, that doesn't mean you can use it. Software projects do not live in isolation, and you have to consider the bigger picture. For example, you might have budget c... | [
0.012802504934370518,
-0.018006766214966774,
-0.04707420617341995,
-0.04415953904390335,
0.03138241916894913,
-0.0444161482155323,
0.06983622908592224,
0.0269690603017807,
0.06878776103258133,
-0.03908612206578255,
0.029654543846845627,
0.008360466919839382,
0.057123325765132904,
-0.056976... |
8de489aa-7f45-5be5-992b-71feab49b28b | /documentation/ops-optimization/read-write-contention/ | Read-Write Contention | documentation | false | Read-Write Contention
Qdrant is designed to index and optimize data as it arrives. While serving search queries, Qdrant's [background optimizer](/documentation/ops-optimization/optimizer/) continuously builds [HNSW indexes](/documentation/manage-data/indexing/#vector-index), merges segments, and applies quantization. ... | [
0.015606069937348366,
-0.05519663169980049,
-0.05481191724538803,
-0.013735300861299038,
0.026651423424482346,
-0.0341406911611557,
0.07969377934932709,
0.03647720813751221,
0.07853224128484726,
-0.014958550222218037,
0.015985779464244843,
-0.008540435694158077,
0.04904860258102417,
-0.018... | |
8defdff0-cbbb-5ed8-9dce-923aa196e1b0 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Best Matching 25 (BM25) > BM25 in Qdrant > Lexical Retrieval with BM25 & Qdrant | course | true | Demo: Keyword Search with Sparse Vectors > Best Matching 25 (BM25) > BM25 in Qdrant > Lexical Retrieval with BM25 & Qdrant
Now let's test our BM25-based lexical search in Qdrant.
Suppose we're searching for the word **"cheese"** — this is our query.
```python
client.query_points(
collection_name=<COLLECTION_NAME... | [
0.08008424937725067,
-0.04496527090668678,
-0.026884624734520912,
-0.027549350634217262,
0.07459995150566101,
-0.03285076469182968,
0.0643760934472084,
0.008083352819085121,
0.07394643127918243,
-0.019991926848888397,
0.031571101397275925,
-0.0005906617734581232,
0.06808203458786011,
-0.03... |
8df385f7-74d7-5266-a97d-e2716c3da111 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > GPUType | documentation | false | API Reference > qdrant.io/v1 > Resource Types > GPUType
_Underlying type:_ _string_
GPUType specifies the type of GPU to use.
_Validation:_
- Enum: [nvidia amd]
_Appears in:_
- [GPU](#gpu)
| Field | Description |
| --- | --- |
| `nvidia` | |
| `amd` | | | [
0.02104407735168934,
-0.07534286379814148,
-0.06810321658849716,
-0.04991212487220764,
0.06977614015340805,
-0.029187055304646492,
0.029849210754036903,
0.06404498964548111,
0.09022948145866394,
-0.032561756670475006,
0.08184593915939331,
-0.014965340495109558,
0.06406128406524658,
-0.0236... |
8e0848e2-b0e6-5f80-8d75-78e7ea110de9 | /documentation/capacity-planning/ | Capacity Planning | Choosing Disk over RAM > Subgroup-Oriented Configuration | documentation | true | Capacity Planning > Choosing Disk over RAM > Subgroup-Oriented Configuration
If your use case involves splitting vectors into multiple collections or subgroups based on payload values (for example, serving searches for multiple users, each with their own subset of vectors), we recommend the `cold` memory tier.
In thi... | [
0.004079671576619148,
-0.06004246696829796,
-0.038093023002147675,
0.0041760168969631195,
0.08474119007587433,
-0.01452731154859066,
0.06753484904766083,
0.043987225741147995,
0.08405546098947525,
-0.004064888693392277,
0.024898651987314224,
0.027064397931098938,
0.035383500158786774,
-0.0... |
8e268953-2e2e-5f55-b777-97401c79cdce | /course/multi-vector-search/module-0/qdrant-setup/ | Qdrant Setup | Local Qdrant Installation | course | true | Qdrant Setup > Local Qdrant Installation
Qdrant's open-source version provides the same features as Qdrant Cloud but requires you to manage the infrastructure yourself. This option works well for development, testing, or when you need full control over your deployment.
### Docker Installation (Recommended)
The faste... | [
0.022825511172413826,
-0.04698978736996651,
-0.018564248457551003,
-0.01545888464897871,
0.02800554223358631,
-0.03383772447705269,
0.07867688685655594,
0.028064284473657608,
0.06450057029724121,
-0.017676444724202156,
0.00018950326193589717,
0.009665876626968384,
0.030229343101382256,
-0.... |
8e3101de-83a0-5af7-b3e5-010760a02c81 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Adding Relevance Feedback Query to a Search Pipeline | documentation | true | Relevance Feedback Retrieval in Qdrant > Adding Relevance Feedback Query to a Search Pipeline
Let's see how introducing the Relevance Feedback Query to a retrieval pipeline could work on this use case.
**Reason:** Let's say you're powering documentation search with `all-MiniLM-L6-v2`, as it's very cheap and fast, but... | [
0.02694101817905903,
-0.03302554413676262,
-0.04524587467312813,
-0.059024978429079056,
0.05464154854416847,
-0.0336412638425827,
0.03582444414496422,
0.02523583173751831,
0.03934682160615921,
0.005496129393577576,
0.02278181165456772,
0.01669933646917343,
0.07300173491239548,
-0.021365761... |
8e35e22c-f5ff-50c6-94f8-d42e4eedda2a | /documentation/tutorials-build-essentials/agentic-rag-camelai-discord/ | Discord RAG Bot | documentation | false | Discord RAG Bot
| Time: 45 min | Level: Intermediate | Stack: Python, Qdrant, CAMEL-AI, OpenAI, discord.py | Output: [GitHub](https://github.com/qdrant/examples/blob/update-discord-bot/disord-bot/discord_rag_bot.ipynb) | [](https://colab.researc... | [
0.0362512432038784,
-0.02483195997774601,
-0.03870955854654312,
-0.017010372132062912,
0.08434444665908813,
-0.010168571956455708,
0.06344440579414368,
0.029813963919878006,
0.05348653346300125,
-0.05627767741680145,
0.04779238626360893,
-0.034266941249370575,
0.06986306607723236,
-0.03351... | |
8e48af41-4b94-5a23-b19b-6eb42a1fb9c1 | /documentation/ops-configuration/usage-statistics/ | Usage Statistics | Why do we collect usage statistics? | documentation | false | Usage Statistics > Why do we collect usage statistics?
We want to make Qdrant fast and reliable. To do this, we need to understand how it performs in real-world scenarios.
We do a lot of benchmarking internally, but it is impossible to cover all possible use cases, hardware, and configurations.
In order to identify b... | [
0.022958045825362206,
-0.05180113762617111,
-0.010142261162400246,
-0.030803531408309937,
0.07306504249572754,
-0.019491707906126976,
0.04417579621076584,
0.03332817554473877,
0.07811053097248077,
-0.03108718991279602,
0.04579976201057434,
0.008465751074254513,
0.09691116213798523,
-0.0360... |
8e7a82db-51b3-5ccc-b040-adedb2c07baf | /course/essentials/day-6/congratulations/ | Course Completion and Next Steps | Skills You've Gained | course | false | Course Completion and Next Steps > Skills You've Gained
You can now design and operate sophisticated vector search systems that balance accuracy, performance, and cost. You understand how to implement hybrid retrieval that combines the best of semantic understanding with keyword precision. You know how to optimize sys... | [
0.013920792378485203,
-0.04553152620792389,
-0.05364382639527321,
-0.0187893845140934,
0.046168629080057144,
-0.06724043935537338,
0.0398508720099926,
0.0346062071621418,
0.044750016182661057,
-0.009634289890527725,
0.019813723862171173,
0.02944531850516796,
0.06988223642110825,
-0.0314505... |
8e9e2ff0-782e-5787-a771-cd5f01b9f0d4 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-3/ | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment | Conclusion | documentation | false | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment > Conclusion
- **Part 1**: [Architecture, Twelve Labs, and NVIDIA VSS](/documentation/tutorials-build-essentials/video-anomaly-edge-part-1/)
- **Part 2**: [Edge-to-Cloud Pipeline](/documentation/tutorials-build-essentials/video-anomaly-edge-part-2/)
-... | [
0.04547986015677452,
-0.026712417602539062,
-0.0846865102648735,
-0.03215445950627327,
0.07026765495538712,
0.009671641513705254,
0.04977189376950264,
0.020311882719397545,
0.07703771442174911,
-0.03713738173246384,
0.07584961503744125,
0.014749613590538502,
0.05753413587808609,
-0.0296704... |
8ea8c9a6-0df0-5862-b206-95304ad0189c | /documentation/manage-data/collections/ | Collections | Create a Collection > Collection with Multiple Vectors | documentation | true | Collections > Create a Collection > Collection with Multiple Vectors
*Available as of v0.10.0*
It is possible to have multiple vectors per record.
This feature allows for multiple vector storages per collection.
To distinguish vectors in one record, they should have a unique [name](/documentation/manage-data/vectors... | [
0.022379042580723763,
-0.05952933430671692,
-0.026362761855125427,
-0.03556527569890022,
0.06821542978286743,
-0.04704424366354942,
0.04524591565132141,
0.04118609428405762,
0.1002948060631752,
-0.04259848967194557,
0.005762294866144657,
0.047666989266872406,
0.078410804271698,
-0.02941368... |
8eacd8f6-f079-5a23-b075-9b8da7a6fc58 | /documentation/tutorials-operations/time-based-sharding/ | Time-Based Sharding | Install and Initialize the Qdrant Client | documentation | true | Time-Based Sharding > Install and Initialize the Qdrant Client
First, install the Qdrant client:
```bash
pip install qdrant-client
```
Next, initialize the client:
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(
url=QDRANT_URL,
api_key=QDRANT_API_KEY,
cloud_inference=Tru... | [
0.030561022460460663,
-0.04368019849061966,
-0.012683873064815998,
-0.06668830662965775,
0.05325378105044365,
-0.035532642155885696,
0.0894920602440834,
0.05661892145872116,
0.06800772994756699,
0.007573549635708332,
0.02473411150276661,
0.005478966049849987,
0.055306900292634964,
-0.04646... |
8ec4b1fe-1a03-552e-9093-268d22db21a0 | /documentation/common-errors/ | Troubleshooting | Can't open Collections meta Wal | documentation | true | Troubleshooting > Can't open Collections meta Wal
When starting a Qdrant instance as part of a distributed deployment, you may
come across an error message similar to this:
```bash
Can't open Collections meta Wal: Os { code: 11, kind: WouldBlock, message: "Resource temporarily unavailable" }
```
It means that Qdrant... | [
0.013151871040463448,
-0.039279960095882416,
-0.006924894172698259,
-0.0033168261870741844,
0.08252781629562378,
-0.08206348121166229,
0.05264601483941078,
0.09154718369245529,
0.053554680198431015,
-0.01093483716249466,
0.03718317672610283,
0.027323879301548004,
0.013616140931844711,
-0.0... |
8ed1929d-5048-5398-85ca-66762503a2b3 | /documentation/production-operations/managed-cloud-prometheus/ | Managed Cloud Prometheus Monitoring | documentation | false | Managed Cloud Prometheus Monitoring
This tutorial will guide you through the process of setting up Prometheus and Grafana to monitor Qdrant databases running in Qdrant Managed Cloud. | [
0.01177352573722601,
-0.020109761506319046,
-0.05265328660607338,
-0.031247969716787338,
0.03408009558916092,
-0.011935246177017689,
0.07245147228240967,
0.025675596669316292,
0.059056606143713,
-0.02176227979362011,
0.04572184011340141,
-0.0024673715233802795,
0.07508594542741776,
-0.0281... | |
8ed49c63-beab-54b9-ab31-d24c741e0061 | /documentation/tutorials-operations/incremental-embedding-updates/ | Incremental Embedding Updates | Syncing with Documentation Changes > Case 2: Content Changed, Re-Embed | documentation | true | Incremental Embedding Updates > Syncing with Documentation Changes > Case 2: Content Changed, Re-Embed
The chunk about Step 3 exists under a known ID (it didn't change its position on the docs website) but carries new information.
Use `upsert`: writing a point under an existing ID replaces it.
```python
def re_embe... | [
0.02634565345942974,
-0.059448134154081345,
-0.029321428388357162,
-0.034672316163778305,
0.049322985112667084,
-0.008567209355533123,
0.034918759018182755,
0.04505457729101181,
0.02863074094057083,
-0.044616494327783585,
0.010871559381484985,
0.0191548690199852,
0.03896118700504303,
-0.03... |
8ed552a7-0aca-5d9b-bc23-76d0daf2b931 | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 2: Statistical Sampling (Recommended) | documentation | false | Search Quality > Tier 2: Statistical Sampling (Recommended)
Tier 2 quantifies search quality using recall@k: the fraction of source system results that appear in Qdrant's results. Instead of eyeballing 10 queries, you measure recall across 50 or more and compute statistics. | [
0.037853486835956573,
-0.05613002926111221,
-0.05407562106847763,
-0.031101515516638756,
0.0357317179441452,
-0.01339754555374384,
0.09025511890649796,
0.04693712294101715,
0.12584885954856873,
-0.024466177448630333,
0.03702998161315918,
0.021191515028476715,
0.0655195340514183,
-0.0251812... |
8edd3ca3-2846-552f-bdd2-0aa08fc6b584 | /course/essentials/day-3/sparse-vectors/ | Sparse Vectors and Inverted Indexes | Sparse Vectors in Qdrant > Store Sparse Vectors in Qdrant | course | true | Sparse Vectors and Inverted Indexes > Sparse Vectors in Qdrant > Store Sparse Vectors in Qdrant
Sparse vectors in Qdrant are represented by:
- `indices` – the indices of non-zero dimensions (stored as `uint32`, so they can range from 0 to 4,294,967,295).
- `indices` must be **unique** within a vector.
- `values` –... | [
0.05366213619709015,
-0.02916988916695118,
-0.03110206127166748,
-0.02455361932516098,
0.04229867458343506,
-0.03831878677010536,
0.050742633640766144,
0.0526123009622097,
0.08430647104978561,
-0.03431686758995056,
-0.006238497328013182,
0.031357910484075546,
0.042513858526945114,
-0.00857... |
8ee5e76f-e7b5-52ca-a630-8cdcbc406e5e | /documentation/search/hybrid-queries/ | Hybrid Queries | Multi-Stage Queries > Re-Scoring Examples | documentation | true | Hybrid Queries > Multi-Stage Queries > Re-Scoring Examples
#### Re-Score with the Full Vector
Fetch 1000 results using a shorter MRL byte vector, then re-score them using the full vector and get the top 10.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
... | [
0.022335678339004517,
-0.029361970722675323,
-0.02937687747180462,
-0.03819752857089043,
0.0463959164917469,
-0.03725983202457428,
0.03119862824678421,
0.014238806441426277,
0.06155027821660042,
-0.02689531072974205,
0.054142165929079056,
0.028435008600354195,
0.03943123668432236,
-0.04726... |
8ee71288-ca69-5738-a175-3cb67ac6fe83 | /course/essentials/day-3/pitstop-project/ | Project: Building a Hybrid Search Engine | Success Criteria | course | false | Project: Building a Hybrid Search Engine > Success Criteria
You'll know you've succeeded when:
Your hybrid collection contains both dense and sparse vectors
You can perform searches using dense, sparse, and hybrid approaches
RRF fusion combines results from both vector types effectively
You can demonstrate c... | [
0.03784243017435074,
-0.04528312757611275,
-0.06805020570755005,
-0.04746216535568237,
0.059711504727602005,
-0.06562045961618423,
0.10853356122970581,
0.03915846347808838,
0.06826391816139221,
-0.05640853941440582,
0.013236642815172672,
0.034797631204128265,
0.042509835213422775,
0.012775... |
8f09aeda-c481-5323-bab5-9a639d77aaf8 | /course/essentials/day-0/pitstop-project/ | Project: Building Your First Vector Search System | Build Steps | course | true | Project: Building Your First Vector Search System > Build Steps
### Step 1: Initialize Client
```python
from qdrant_client import QdrantClient, models
import os
client = QdrantClient(url=os.getenv("QDRANT_URL"), api_key=os.getenv("QDRANT_API_KEY"))
# For Colab:
# from google.colab import userdata
# client = QdrantC... | [
0.02627408690750599,
-0.08034231513738632,
-0.010579684749245644,
-0.003046040190383792,
0.0668952614068985,
-0.04692855849862099,
0.03815500810742378,
0.04255067557096481,
0.0665789246559143,
-0.0077654835768043995,
0.027159687131643295,
0.0363190583884716,
0.05800168961286545,
-0.0413183... |
8f178596-7a3c-58fd-9aa7-8999704cd6fd | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | Practical Implementation | course | true | Combining Vector Search and Filtering > Practical Implementation
### Setting Up Filterable Search
The following example illustrates how filtering is carried out in practice:
```python
# Create filter combining multiple conditions
filter_conditions = models.Filter(
must=[
models.FieldCondition(key="catego... | [
0.021846216171979904,
-0.06526577472686768,
-0.05030493810772896,
-0.031525421887636185,
0.059958476573228836,
-0.011518693529069424,
0.07197551429271698,
0.04319224879145622,
0.0729418471455574,
-0.0102682551369071,
0.0594254732131958,
0.02604266256093979,
0.05707850307226181,
-0.04665442... |
8f193c2b-adcd-5b0e-a15a-1388626b58af | /course/essentials/day-5/universal-query-demo/ | Demo: Universal Query for Hybrid Retrieval | course | false | Demo: Universal Query for Hybrid Retrieval
Day 5
In this hands-on demo, we'll build a research paper discovery system using the arXiv dataset that showcases the full power of Qdrant's Universal Query API. You'll see how to combine dense semantics, sparse keywords, and ColBERT reranking to help researchers find exactl... | [
0.04791826009750366,
-0.003992519341409206,
-0.059273216873407364,
-0.033738501369953156,
0.08896209299564362,
-0.04584423452615738,
0.0486455075442791,
0.0691927894949913,
0.06176101043820381,
-0.03499836102128029,
0.05973932892084122,
0.05007413029670715,
0.08575799316167831,
-0.03542575... | |
8f195f2f-3424-5141-ae4c-ee380e7e33f1 | /course/essentials/day-3/hybrid-search-demo/ | Demo: Implementing a Hybrid Search System | Step 4: Compare Dense vs. Sparse Search | course | true | Demo: Implementing a Hybrid Search System > Step 4: Compare Dense vs. Sparse Search
Let's create helper functions to test each search method independently. First, dense search:
```python
def dense_search(query: str) -> list[models.ScoredPoint]:
response = client.query_points(
collection_name=collection_na... | [
0.03306884318590164,
-0.05021897703409195,
-0.06611192971467972,
-0.05030805990099907,
0.06619297713041306,
-0.03291281685233116,
0.06298594921827316,
0.017306463792920113,
0.09739077091217041,
-0.03852228447794914,
0.03441731631755829,
0.04897290840744972,
0.044118281453847885,
0.00252067... |
8f2d8c75-07aa-5404-acaf-0a1d14eaf54c | /documentation/search/text-search/full-text-search/ | Full-Text Search | documentation | false | Full-Text Search
Full-text search is similar to full-text filtering, with the key difference being that full-text queries are used for ranking. For each document that matches the search terms, Qdrant calculates a relevance score based on how well the document matches the search terms. That score is used to rank the re... | [
0.05823018029332161,
-0.05352529510855675,
-0.060453832149505615,
-0.0477561317384243,
0.04935189709067345,
-0.01152830757200718,
0.09168784320354462,
0.025025026872754097,
0.08383424580097198,
0.0008486740407533944,
0.05249720811843872,
0.03386376425623894,
0.052363280206918716,
0.0000397... | |
8f36a9dd-1ea3-5096-910f-5eb6de997f10 | /documentation/embeddings/mixedbread/ | Mixedbread | Embed Documents | documentation | true | Mixedbread > Embed Documents
`encode_document` embeds a list of documents and returns the vectors in input order, which this example uses for the point IDs:
```python
documents = [
"Qdrant is a vector search engine.",
"Mixedbread publishes open-weight embedding models on Hugging Face.",
]
embeddings = model.... | [
0.05855942144989967,
-0.06242998316884041,
-0.02581486850976944,
-0.0730087086558342,
0.04702472686767578,
-0.012566205114126205,
0.056323785334825516,
0.0697033628821373,
0.04472962021827698,
-0.03340592980384827,
-0.01941491849720478,
0.027358505874872208,
0.03835941478610039,
-0.0457782... |
8f399f59-6ea9-5843-9fed-d562a5d86de0 | /documentation/migration-guidance/pre-migration-baseline/ | Pre-Migration Baseline | documentation | false | Pre-Migration Baseline
Establishing a baseline is paramount for migration verification. If you don't capture what "correct" looks like before you migrate, you have nothing to compare against afterward. This page covers what to record from your source system before starting the migration. | [
-0.0013129368890076876,
-0.06615011394023895,
-0.003784196451306343,
-0.10023427754640579,
0.02040662057697773,
-0.006842318922281265,
0.04933585971593857,
0.028383972123265266,
0.0443619005382061,
-0.027346035465598106,
0.045593976974487305,
0.012885906733572483,
0.05621543899178505,
-0.0... | |
8f461166-f8e9-58fe-b144-6c66426446fa | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | Retrieve data via filters | documentation | true | How to Implement Multitenancy and Custom Sharding in Qdrant > Retrieve data via filters
The access control setup is completed as you specify the criteria for data retrieval. When searching for vectors, you need to use a `query_filter` along with `group_id` to filter vectors for each user.
```python
client.query_point... | [
0.012880323454737663,
-0.049180060625076294,
-0.046508099883794785,
-0.00925340037792921,
0.049269456416368484,
-0.010577925480902195,
0.060187581926584244,
0.038305122405290604,
0.05513213574886322,
-0.012158014811575413,
0.019869232550263405,
0.06460850685834885,
0.11890973895788193,
-0.... |
8f52ca9d-5e90-5a7e-8e86-8955d3650014 | /documentation/security/ | Security | Audit Logging > Tracing IDs | documentation | true | Security > Audit Logging > Tracing IDs
*Available as of v1.18.0*
You can attach a tracing ID to individual requests. When audit logging is enabled, Qdrant includes the tracing ID in the audit log entry, enabling the correlation of client-side operations with their corresponding log entries.
Qdrant reads the tracing ... | [
0.04020584002137184,
-0.039281394332647324,
-0.05378589779138565,
-0.057133082300424576,
0.028859548270702362,
-0.026873990893363953,
0.013113473542034626,
0.07157711684703827,
0.0867515280842781,
-0.03749492019414902,
0.021806424483656883,
-0.0002574934624135494,
0.07602369040250778,
-0.0... |
8f5b0c1c-4f04-544e-aa02-f6fdee033236 | /documentation/platforms/tooljet/ | ToolJet | documentation | false | ToolJet
[ToolJet](https://www.tooljet.com) is a low-code platform for building business applications. Connect to databases, cloud storages, GraphQL, API endpoints, Airtable, Google sheets, OpenAI, etc and build apps using drag and drop application builder.
## Prerequisites
1. A Qdrant instance to connect to. You can... | [
0.01753217540681362,
-0.055665548890829086,
-0.04131992906332016,
-0.0556136816740036,
0.021101975813508034,
-0.013458709232509136,
0.03348758816719055,
0.028779329732060432,
0.04649373143911362,
-0.029644548892974854,
0.06227865070104599,
0.04559342935681343,
-0.006480401381850243,
-0.038... | |
8f5c711e-4e1b-5880-9cf0-5526c1480f95 | /documentation/fastembed/fastembed-colbert/ | Working with ColBERT | Querying | documentation | true | Working with ColBERT > Querying
ColBERT uses two distinct methods for embedding documents and queries, as do we in Fastembed. However, we altered query pre-processing used in ColBERT, so we don't have to cut all queries after 32-token length but ingest longer queries directly.
```python
qdrant_client.query_points(
... | [
0.021545689553022385,
-0.009479207918047905,
-0.02530805952847004,
-0.03781728446483612,
0.06476885825395584,
-0.03863168880343437,
0.07906585186719894,
0.08660993725061417,
0.07437241077423096,
-0.006161035504192114,
0.02301943674683571,
0.012644377537071705,
0.020791584625840187,
-0.0303... |
8f8e317e-27a6-51a8-a8e0-60eb828c87d4 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantSecurityContext | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantSecurityContext
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `user` _integer_ | User specifies the user to run the Qdrant process as. | | |
| `group` _integer_ | Group specifie... | [
0.03629961982369423,
-0.04957342520356178,
-0.013154299929738045,
-0.04667499661445618,
0.07867449522018433,
-0.05118156969547272,
0.06906288862228394,
0.06012484431266785,
0.05715843662619591,
-0.02749507874250412,
0.03141423687338829,
-0.00040239887312054634,
0.06925536692142487,
-0.0378... |
8f9711ba-f2a4-51a7-b52c-748418f62179 | /course/beginners/module-4/where-it-runs/ | Where It Runs | course | false | Where It Runs
Module 4
Deployment mode is independent of the design decisions in this module. Choose based on how much you want to run yourself and how isolated the data needs to be. Four modes run Qdrant as a server:
- **[Managed Cloud](/documentation/cloud/)** runs it for you, with upgrades, backups, and replicati... | [
0.024932848289608955,
-0.021572457626461983,
-0.0760226920247078,
-0.03349463641643524,
0.093476802110672,
-0.02177983522415161,
0.0657620057463646,
0.03170289099216461,
0.06322325021028519,
-0.02269761823117733,
0.012480036355555058,
-0.0009093326516449451,
3.30857794494932e-8,
-0.0161582... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.