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 |
|---|---|---|---|---|---|---|---|
b97d5e67-894b-5b33-8bc1-c67d9ada1564 | /documentation/security/ | Security | Audit Logging | documentation | true | Security > Audit Logging
*Available as of v1.17.0*
Audit logging records all API operations that require authentication or authorization, and writes them in JSON format, by default to log files.
Audit logging is not enabled by default. To enable it, use the following configuration options:
```yaml
audit:
enabled:... | [
-0.0126577103510499,
-0.05819406732916832,
0.014696682803332806,
-0.06000208854675293,
0.060752127319574356,
-0.07402927428483963,
-0.013441083952784538,
0.07513172924518585,
0.0552542619407177,
-0.036847833544015884,
0.012316553853452206,
0.048630569130182266,
0.06604326516389847,
-0.0644... |
b9819ed4-fb16-5d0f-adf5-5a0b363ce6e9 | /articles/memory-consumption/ | Minimal RAM to Serve 1M Vectors | Let's run some benchmarks > Vectors stored using MMAP | article | true | Minimal RAM to Serve 1M Vectors > Let's run some benchmarks > Vectors stored using MMAP
Let's go a bit further!
In the second experiment, we tested how well our system performs when **vectors are stored using the memory-mapped file** (mmap).
Create collection with:
```http
PUT /collections/benchmark
{
"vectors": {
... | [
0.029326332733035088,
-0.0453079491853714,
-0.05612877383828163,
-0.037438180297613144,
0.07695786654949188,
-0.047272466123104095,
0.02668059803545475,
0.024825548753142357,
0.09454036504030228,
-0.014846890233457088,
0.01607239618897438,
-0.0019398138392716646,
0.054709162563085556,
-0.0... |
b9942d9f-74cd-5f90-8a33-e1f9e4ef8c14 | /documentation/search-patterns/vector-search-filtering/ | Filtering in Vector Search: When to Use What | Filter During the Search, Not Before or After | documentation | false | Filtering in Vector Search: When to Use What > Filter During the Search, Not Before or After
There are two traditional ways to combine a filter with vector search, and both have a cost.
- **Post-filtering** runs the vector search first and then drops results that fail the filter. If many of the top results fail, you ... | [
0.022250784561038017,
-0.07022976130247116,
-0.04995403811335564,
-0.023172108456492424,
0.08472969383001328,
-0.017868824303150177,
0.03700944408774376,
-0.0027881995774805546,
0.09548065066337585,
-0.015197204425930977,
0.05928727984428406,
0.02948254533112049,
0.03713247925043106,
-0.00... |
b9956be5-51af-5798-a4bb-59516a3e0d7b | /documentation/migration-guidance/diagnosing-discrepancies/ | Diagnosing Discrepancies | Configuration-Level Issues > Distance Metric Mismatch | documentation | true | Diagnosing Discrepancies > Configuration-Level Issues > Distance Metric Mismatch
## Decision Tree
Start here when any verification check fails:
```
Is the vector count wrong?
├─ Yes → Data-level issue
│ ├─ Count lower than expected → Check migration script logs for errors,
│ │ timeouts, or partial failures. Re... | [
0.04914966970682144,
0.006557390093803406,
-0.029760051518678665,
-0.00723451841622591,
0.04643925279378891,
-0.019788021221756935,
0.04445246234536171,
0.05295834690332413,
0.06492362916469574,
-0.02706083282828331,
-0.0051261247135698795,
0.0029451274313032627,
0.044041212648153305,
-0.0... |
b99ce402-247f-59aa-90c7-0e21d7451ef5 | /documentation/search/explore/ | Explore | Recommendation API > Lookup Vectors From Another Collection | documentation | true | Explore > Recommendation API > Lookup Vectors From Another Collection
*Available as of v0.11.6*
If you have collections with vectors of the same dimensionality,
and you want to look for recommendations in one collection based on the vectors of another collection,
you can use the `lookup_from` parameter.
It might be ... | [
0.055820170789957047,
-0.0795082151889801,
-0.034381281584501266,
-0.03807200491428375,
0.06843598186969757,
-0.014214061200618744,
0.06030498445034027,
0.057565003633499146,
0.07481355965137482,
-0.04224836081266403,
0.05187823250889778,
0.0572788380086422,
0.02573166787624359,
0.00296776... |
b9a8fc68-e62f-5310-9ee0-2bf7dd8b139d | /documentation/security/ | Security | Audit Logging > Query Audit Logs > Narrowing Results with Time Ranges and Filters | documentation | true | Security > Audit Logging > Query Audit Logs > Narrowing Results with Time Ranges and Filters
To narrow results to a specific time range, use the `time_from` (inclusive) and `time_to` (exclusive) parameters.
The `filters` parameter enables exact-match filtering of entries based on specific field values. The parameter ... | [
-0.004920908249914646,
-0.07300275564193726,
-0.01606290601193905,
-0.04274199903011322,
0.05896852910518646,
-0.037730008363723755,
0.051109664142131805,
0.0982823297381401,
0.08024947345256805,
-0.02159673534333706,
-0.0046411179937422276,
0.03478808328509331,
0.05329199880361557,
-0.022... |
b9b986e4-3e04-5931-b612-e0c865eef7e3 | /documentation/migration-guidance/data-integrity/ | Data Integrity | 4. Metadata (Payload) Verification | documentation | true | Data Integrity > 4. Metadata (Payload) Verification
Metadata verification checks three things: field presence, field types, and field values.
### 4a. Field Presence
Check that all expected metadata fields exist in Qdrant:
```py
import random
# Sample points from Qdrant using scroll
records, _next = client.scroll(
... | [
0.06256217509508133,
-0.026685727760195732,
-0.05768004059791565,
-0.04007071256637573,
0.04585495963692665,
-0.02241670899093151,
0.023359371349215508,
0.05605410411953926,
0.046790286898612976,
-0.04355064779520035,
0.027447005733847618,
0.022569207474589348,
0.0635160505771637,
-0.01529... |
b9e538f3-cf31-5c4c-8802-5d52110138bf | /documentation/private-cloud/qdrant-cluster-management/ | Managing a Cluster | Authentication and Authorization > Configuring TLS for Inter-cluster Communication | documentation | true | Managing a Cluster > Authentication and Authorization > Configuring TLS for Inter-cluster Communication
*Available as of Operator v2.2.0*
The feature can be enabled only at the cluster creation. Later changes are not possible.
If you want to encrypt communication between Qdrant nodes, you need to enable TLS by provi... | [
0.051277849823236465,
-0.049758605659008026,
-0.06636949628591537,
-0.005562853068113327,
0.022496024146676064,
-0.058687884360551834,
0.06172429770231247,
0.06100042164325714,
0.03283475339412689,
-0.001883006189018488,
0.015619772486388683,
-0.02072933316230774,
0.0725894570350647,
-0.02... |
ba284ab4-50d9-5aee-90ea-1bc627fcbe71 | /documentation/tutorials-develop/search-as-you-type/ | Semantic Search As You Type | Step 6: Try It | documentation | true | Semantic Search As You Type > Step 6: Try It
Add the following to run the whole flow and print the results for three queries. The first run downloads the embedding model.
```python
async def main() -> None:
await create_collections()
await index_documents()
await build_prefix_cache()
for text in ["qua... | [
0.046788811683654785,
-0.08374553918838501,
-0.019467409700155258,
-0.015620797872543335,
0.058108847588300705,
-0.029980052262544632,
0.03681175038218498,
0.01536497101187706,
0.025969572365283966,
-0.009587753564119339,
0.024235351011157036,
0.0036235442385077477,
0.03645038232207298,
-0... |
ba4078a3-2ed7-5c29-a861-2fb8a487517b | /documentation/overview/vector-search/ | Understanding Vector Search in Qdrant | Why Qdrant? | documentation | false | Understanding Vector Search in Qdrant > Why Qdrant?
The challenge with vector search arises when we need to find similar documents in a big set of objects. If we want to find the closest examples, the naive approach would require calculating the distance to every document. That might work with dozens or even hundreds ... | [
0.04190247133374214,
-0.06787573546171188,
-0.0627116858959198,
-0.006444194354116917,
0.05645456910133362,
-0.03289535269141197,
0.08774161338806152,
0.040285252034664154,
0.08493277430534363,
-0.014019569382071495,
0.012307364493608475,
0.04474605992436409,
0.050526320934295654,
-0.02156... |
ba497f3d-bffa-516d-a24c-27cfd5b2abf7 | /documentation/search/search/ | Search | Query by ID | documentation | true | Search > Query by ID
Whenever you need to use a vector as an input, you can always use a [point ID](/documentation/manage-data/points/#point-ids) instead.
```python
client.query_points(
collection_name="{collection_name}",
query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04", # <--- point id
)
```
The above example ... | [
0.07945958524942398,
-0.07791847735643387,
-0.022423019632697105,
-0.011494609527289867,
0.04819121211767197,
-0.049777526408433914,
0.04505939036607742,
0.06434784084558487,
0.07631641626358032,
0.009286586195230484,
0.023261837661266327,
0.007014925125986338,
0.018056537955999374,
-0.034... |
ba49c3d3-2adf-5006-9eb0-5ba0c43f221d | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 4. Ensuring Disaster Recovery With Database Backups and Snapshots > Best Ways To Backup Large Deployments | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 4. Ensuring Disaster Recovery With Database Backups and Snapshots > Best Ways To Backup Large Deployments
If you host tens of billions of vectors, store backups off-node in a different data center or a remote repository. Also, confirm your restore bandwidth is ... | [
0.009892257861793041,
-0.0362875871360302,
-0.020588194951415062,
-0.040996253490448,
0.045408181846141815,
-0.04840455949306488,
0.0503971166908741,
0.005475146695971489,
0.06537649035453796,
-0.028482722118496895,
0.03227369487285614,
0.03825605288147926,
0.021110108122229576,
-0.0352359... |
ba5bee9c-0570-5f36-8277-9b68e22afb95 | /course/multi-vector-search/module-3/muvera/ | MUVERA | Applying MUVERA Multi-Stage Retrieval > Creating the Collection | course | true | MUVERA > Applying MUVERA Multi-Stage Retrieval > Creating the Collection
For multi-stage retrieval to work, you need to index **both** the MUVERA approximation vectors and the original multi-vector representations in Qdrant. The MUVERA vectors enable fast HNSW retrieval, while the multi-vector representations provide ... | [
0.05197586119174957,
-0.05513009428977966,
-0.027250127866864204,
-0.05543193221092224,
0.07065349817276001,
-0.02533220313489437,
0.03860216587781906,
0.018421096727252007,
0.063374362885952,
-0.0015927344793453813,
0.018544090911746025,
0.05120975524187088,
0.0540652759373188,
-0.0414020... |
ba5ef09c-e736-5577-9b0c-bc59c72c8a68 | /documentation/cloud-cli/ | Qdrant Cloud CLI | documentation | false | Qdrant Cloud CLI
`qcloud` is the official command-line interface for managing Qdrant Cloud. It lets you manage clusters, authentication, and anything the Qdrant Cloud API has to offer—all from your terminal. | [
-0.000637040298897773,
0.00846272986382246,
-0.05284009501338005,
-0.05951843038201332,
0.050361406058073044,
-0.03614437207579613,
0.08767712861299515,
0.045598097145557404,
0.08155802637338638,
-0.03742336109280586,
0.03828961402177811,
-0.006178124342113733,
0.0722884014248848,
-0.03462... | |
ba7f9835-9a68-5b18-ad6e-d3e919d09bd7 | /course/beginners/module-0/qdrant-cloud/ | Qdrant Setup | Connect from Python | course | true | Qdrant Setup > Connect from Python
Now let's connect from code. First, store your credentials in a file named `.env` at the root of your project (or set them in Colab). Keeping them in a separate file means you won't accidentally paste your key into shared code:
```env
QDRANT_URL=https://YOUR-CLUSTER.cloud.qdrant.io:... | [
0.015627678483724594,
-0.07082545757293701,
-0.012121501378715038,
-0.031616710126399994,
0.033145029097795486,
-0.0723409429192543,
0.06779547035694122,
0.048077140003442764,
0.060413505882024765,
-0.03792167454957962,
-0.0005396904889494181,
-0.010404315777122974,
0.09817725419998169,
-0... |
ba931378-88ce-5fd7-9a8a-053c1cd758f0 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | From Words to Concepts > Standing on the Shoulders of BM25, Again (We Got Comfortable) | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > From Words to Concepts > Standing on the Shoulders of BM25, Again (We Got Comfortable)
> **Note:** The BM25 formula is suitable not only for words: the probabilistic relevance framework behind it states *"the model is not restricted to terms and ter... | [
0.035720016807317734,
-0.030383137986063957,
-0.04319607838988304,
-0.04775824397802353,
0.08106478303670883,
-0.05154227092862129,
0.048844024538993835,
0.000052335308282636106,
0.056144531816244125,
-0.012099805288016796,
0.010094922035932541,
0.01552610658109188,
0.09821055829524994,
-0... |
ba99f860-1a90-5fe2-be75-7e1a6ac44d26 | /course/multi-vector-search/module-1/use-cases-multi-vector/ | Use Cases for Multi-Vector Search | A Concrete Demonstration > Single-Vector Embeddings: Missing the Details | course | true | Use Cases for Multi-Vector Search > A Concrete Demonstration > Single-Vector Embeddings: Missing the Details
First, let's try the traditional approach using a single dense vector per document:
```python
from fastembed import TextEmbedding
# Load the BAAI/bge-small-en-v1.5 model
dense_model = TextEmbedding("BAAI/bge-... | [
0.05823499336838722,
-0.08458106219768524,
-0.05948939546942711,
-0.046638842672109604,
0.045998960733413696,
-0.0012876704568043351,
0.04689187929034233,
0.010351822711527348,
0.09419011324644089,
-0.018561309203505516,
0.01366126537322998,
0.01768556609749794,
0.05265699326992035,
-0.021... |
bab79036-6e3b-53bf-976a-f366e72ac431 | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | Make Sure Your Labels Can Detect a Gain | documentation | true | What to Check Before Tuning a Qdrant Collection > Make Sure Your Labels Can Detect a Gain
Resample the per-query gains with replacement to estimate how much the average gain would move if you had drawn a different set of queries. The resulting 95% interval shows the range consistent with that sampling variation. If th... | [
0.0009717658977024257,
-0.04341086372733116,
-0.06116512790322304,
-0.03102847933769226,
0.03314957767724991,
-0.016194108873605728,
0.05643833428621292,
0.06160692870616913,
0.06479975581169128,
-0.059480443596839905,
0.014405823312699795,
0.030504869297146797,
0.03415317460894585,
-0.036... |
babb34ae-8225-53d9-9096-0c6517905837 | /documentation/ | Documentation | Tutorials & Examples | documentation | false | Documentation > Tutorials & Examples
- [Tutorials](/documentation/tutorials-lp-overview/index.md) — Hub for all tutorials covering basics, search engineering, retrieval quality, operations, migrations, and ecosystem integrations.
- [Examples](/documentation/examples/index.md) — End-to-end code samples for RAG pipeline... | [
-0.009896902367472649,
-0.04825521633028984,
-0.08450235426425934,
-0.05065802484750748,
0.06794387847185135,
-0.01761322095990181,
0.08595477789640427,
0.03602933883666992,
0.06390862166881561,
-0.03522307425737381,
0.017602035775780678,
0.023249046877026558,
0.0686325952410698,
-0.048321... |
bae2199b-d3d1-50f2-9b72-78b8c5554249 | /documentation/tutorials-basics/search-beginners/ | Semantic Search 101 | Overview | documentation | false | Semantic Search 101 > Overview
If you are new to vector search engines, this tutorial is for you. In 5 minutes you will build a semantic search engine for science fiction books. After you set it up, you will ask the engine about an impending alien threat. Your creation will recommend books as preparation for a potenti... | [
0.0223487950861454,
-0.045428115874528885,
-0.044425543397665024,
-0.02926819398999214,
0.08493593335151672,
-0.02570076659321785,
0.03927045688033104,
0.029857372865080833,
0.04402772709727287,
-0.011328076012432575,
0.024466201663017273,
0.024887191131711006,
0.05361669510602951,
-0.0370... |
bafb7a3e-e7dd-582e-8da2-67c044322adb | /documentation/tutorials-search-engineering/index-dynamic-payloads/ | Indexing Payloads of Random Shape | documentation | false | Indexing Payloads of Random Shape
| Time: 25 min | Level: Intermediate |
| --- | ----------- |
Most collections have a fixed schema: a price, a category, a timestamp. This tutorial is about the ones where the payload keys themselves are data, like a catalog ingesting each vendor's raw feed. A collection like that can... | [
0.02936660312116146,
-0.005574284587055445,
-0.05547856539487839,
-0.05046268180012703,
0.04660060629248619,
-0.05571841076016426,
0.023287193849682808,
0.04691720008850098,
0.12155365198850632,
-0.027438830584287643,
0.02225794829428196,
0.022544803097844124,
0.059146538376808167,
-0.0340... | |
bb0d2b52-fe7b-5018-862e-9b8fdf1222e6 | /course/essentials/day-2/pitstop-project/ | Project: HNSW Performance Benchmarking | Share Your Discovery | course | true | Project: HNSW Performance Benchmarking > Share Your Discovery
### Step 1: Reflect on Your Findings
1. Which HNSW configuration (`m`, `ef_construct`) worked best for your domain?
2. How did the balance between upload time and search speed look?
3. What was the impact of adding a payload index?
4. How do your results c... | [
0.02779003605246544,
-0.03375062718987465,
-0.07031679898500443,
-0.02107827551662922,
0.04070514813065529,
-0.059764325618743896,
0.07962146401405334,
0.0458645336329937,
0.06132377311587334,
-0.039929091930389404,
0.025387488305568695,
0.0030295078177005053,
0.04369116947054863,
-0.02880... |
bb26211c-1140-5e41-8274-8e77ccc46590 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Scalar Quantization > Theoretical Background > Conversion to Integers | article | false | Scalar Quantization for Vector Search > Scalar Quantization > Theoretical Background > Conversion to Integers
Let's talk about the conversion to `int8`. Integers also have a finite set of values that
might be represented. Within a single byte they may represent up to 256 different values,
either from `[-128, 127]` or ... | [
0.0482303723692894,
-0.036802008748054504,
-0.043833956122398376,
-0.04455834999680519,
0.0428922213613987,
-0.03142338618636131,
0.04070232808589935,
0.07999999076128006,
0.0854572057723999,
-0.014192139729857445,
0.037646111100912094,
0.03203658014535904,
0.04712183400988579,
-0.03765091... |
bb2c13e4-7ff2-50aa-a318-96e4491af948 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-2/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 2: Training SPLADE on Modal | Inference-Free SPLADE | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 2: Training SPLADE on Modal > Inference-Free SPLADE
Standard SPLADE runs the transformer on every query. Inference-free SPLADE runs it only on documents, at index time, so documents keep their neural expansions while queries skip the model entirely. Query cost... | [
0.06766721606254578,
-0.05165139213204384,
-0.020435521379113197,
-0.044850848615169525,
0.028803041204810143,
-0.04929770156741142,
0.0674811601638794,
0.038826800882816315,
0.041768878698349,
-0.011599767953157425,
0.002319148974493146,
0.02099357359111309,
0.02635643072426319,
-0.012592... |
bb3ddbaf-a375-56ce-850f-fc15c7f9cf88 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search > ACID: Prioritizing Consistency | article | false | Why Vector Search Needs a Dedicated Database > Vector Search > ACID: Prioritizing Consistency
The ACID model ensures that every transaction (a group of operations treated as a single unit, such as transferring money between accounts) is executed fully or not at all (reverted), leaving the database in a valid state. Wh... | [
0.02414082922041416,
-0.06382361054420471,
-0.07381530851125717,
-0.023010220378637314,
0.050750356167554855,
-0.020578792318701744,
0.05286172032356262,
0.00934385135769844,
0.08201616257429123,
-0.009848294779658318,
0.0332200862467289,
0.054154977202415466,
0.041866887360811234,
-0.0148... |
bb414112-d112-54aa-9dd9-bef0e9fcd3f0 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > NodeStatus | documentation | false | API Reference > qdrant.io/v1 > Resource Types > NodeStatus
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `containerStatuses` _[ContainerStatus](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.28/#containerstatus-v1-core) array_ | Details container statuses of the Pod of th... | [
0.0396638847887516,
-0.03773277625441551,
0.0016929435078054667,
-0.05173039063811302,
0.033247485756874084,
-0.05531921237707138,
0.05266853794455528,
0.04910339042544365,
0.07375568151473999,
-0.03516678512096405,
0.04683895781636238,
-0.0008507567108608782,
0.0278392992913723,
-0.027457... |
bb56b195-323b-5a15-8c47-938a3b7b3941 | /documentation/tutorials-build-essentials/agentic-rag-crewai-zoom/ | Agentic RAG with CrewAI | Usage > Orchestrating the Workflow | documentation | true | Agentic RAG with CrewAI > Usage > Orchestrating the Workflow
The magic happens when we bring these tools together under our agent framework. We create two specialized agents:
```python
researcher = Agent(
role='Research Assistant',
goal='Find and analyze relevant information',
tools=[calculator, searcher,... | [
0.0012755824718624353,
-0.025435645133256912,
-0.07013494521379471,
-0.022920288145542145,
0.09270302951335907,
-0.027520470321178436,
0.0399395115673542,
0.04449503496289253,
0.05892828851938248,
-0.015969382598996162,
0.025515856221318245,
0.021191410720348358,
0.07164916396141052,
0.015... |
bb7619c4-04b3-5662-adf3-7fdfa033f107 | /documentation/search-tuning/candidate-depth/ | Candidate Depth: How Much Retrieval Is Enough? | The Short Version | documentation | false | Candidate Depth: How Much Retrieval Is Enough? > The Short Version
1. Test `limit` at 100 and 200 for a downstream ranking stage. Treat those values as a starting point, not a production default: `limit` applies per shard, and a reranker scores every candidate.
2. Before raising [`hnsw_ef`](/documentation/search/searc... | [
0.026853475719690323,
-0.08507154136896133,
-0.01849503628909588,
-0.053966160863637924,
0.049224331974983215,
-0.03970987722277641,
0.033435970544815063,
0.057155560702085495,
0.1209016963839531,
-0.010184948332607746,
0.033921487629413605,
0.022115204483270645,
0.05782788246870041,
-0.02... |
bb798440-7077-5c89-9294-ec70cc7b4ea6 | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Vectors > How many vectors can I store in a point? Can a point have no vector at all? | documentation | false | Qdrant Fundamentals > Vectors > How many vectors can I store in a point? Can a point have no vector at all?
A point can hold any number of named vector fields (dense, sparse, and multivector), though each has to be configured in the collection's schema. There is no hard limit on the number of named vector fields per p... | [
0.027384568005800247,
-0.021990587934851646,
-0.02032850682735443,
-0.023593993857502937,
0.033300917595624924,
-0.06784355640411377,
0.05208677425980568,
0.05211125686764717,
0.0918404757976532,
-0.047662537544965744,
0.022869057953357697,
0.021227650344371796,
0.04925478622317314,
-0.018... |
bbb60d4b-7685-519d-b9f4-87ca1c80783d | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Sparse Vector Length | documentation | true | Administration > Strict Mode > Maximum Sparse Vector Length
Long sparse vectors increase memory usage and slow down filtering.
Setting `sparse_config` caps the maximum length of sparse vectors for each named vector.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost... | [
0.045426711440086365,
-0.03996416553854942,
-0.018371613696217537,
-0.02520737610757351,
0.04610418900847435,
-0.04397483542561531,
0.05328185856342316,
0.03525178134441376,
0.07181011885404587,
-0.05160032957792282,
-0.03684892877936363,
0.021346502006053925,
0.08333354443311691,
-0.03268... |
bbda5bbb-e5e9-5c01-9f2c-b8e93b844156 | /documentation/hybrid-cloud/ | Hybrid Cloud | Getting Access to Hybrid Cloud | documentation | false | Hybrid Cloud > Getting Access to Hybrid Cloud
Qdrant Hybrid Cloud is available as part of our Enterprise plan. To get access to Qdrant Hybrid Cloud, please [contact us](/contact-us/). | [
-0.007989311590790749,
0.013968711718916893,
-0.044514331966638565,
-0.07418163865804672,
0.0861932784318924,
-0.01895592361688614,
0.08096139132976532,
0.04285910725593567,
0.05106436461210251,
-0.005042657721787691,
0.029597876593470573,
0.005539107136428356,
0.08033080399036407,
-0.0512... |
bbe60e39-87b0-546d-a902-89f09eb3bbd3 | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | Which Framework is Best? > AutoGen | article | true | What is Agentic RAG? Building Agents with Qdrant > Which Framework is Best? > AutoGen
AutoGen emphasizes multi-agent architectures as a fundamental design principle. The framework requires at least two
agents in any system to really call an application agentic - typically an assistant and a user proxy exchange messag... | [
-0.003363054944202304,
-0.033115774393081665,
-0.05125921964645386,
-0.019324181601405144,
0.08743679523468018,
-0.04905223473906517,
0.04971512407064438,
-0.0021465064492076635,
0.06732834130525589,
-0.06966595351696014,
0.06302842497825623,
0.015335536561906338,
0.0602215901017189,
0.002... |
bbe66d73-1940-57cf-af7c-82cac341b808 | /course/multi-vector-search/module-3/quantization-techniques/ | Vector Quantization Techniques | Quantization: Compressing Without Losing Quality > Binary Quantization: Maximum Compression | course | false | Vector Quantization Techniques > Quantization: Compressing Without Losing Quality > Binary Quantization: Maximum Compression
**Binary quantization** represents each component as a single bit (positive/negative), achieving **32x compression**. Qdrant also supports **1.5-bit** and **2-bit** variants for better accuracy ... | [
0.03613659366965294,
-0.05782743915915489,
-0.06140109896659851,
-0.06377951800823212,
0.04235737770795822,
-0.002133785281330347,
0.049548711627721786,
0.05501807481050491,
0.11436360329389572,
-0.024299362674355507,
0.010506733320653439,
-0.019692976027727127,
0.058932896703481674,
-0.04... |
bbf06c9b-7811-50e5-ba1f-354fa9662439 | /documentation/tutorials-operations/scaling-and-monitoring-pods/ | Scaling and Monitoring Hybrid Cloud | documentation | false | Scaling and Monitoring Hybrid Cloud
| Time: 25 min | Level: Intermediate | Stack: Kubernetes, Qdrant Hybrid Cloud |
| --- | --- | --- |
Scaling a Qdrant cluster on Hybrid Cloud looks like a Kubernetes problem from the outside: you have a pod, and you want it to have more CPU, memory, or disk. In practice, the Operato... | [
0.026677630841732025,
0.017146693542599678,
-0.05211406201124191,
-0.04976285621523857,
0.06842398643493652,
-0.0438230037689209,
0.0547659657895565,
0.03101165220141411,
0.08416223526000977,
-0.054643064737319946,
0.034707676619291306,
-0.017945893108844757,
0.047719139605760574,
-0.02447... | |
bc41177e-77e9-5bc4-9245-546b646c315b | /course/essentials/day-5/universal-query-demo/ | Demo: Universal Query for Hybrid Retrieval | Key Takeaways | course | false | Demo: Universal Query for Hybrid Retrieval > Key Takeaways
- **Single Request**: Complex multi-stage research discovery in one API call
- **Parallel Execution**: Dense and sparse searches run concurrently
- **Smart Filtering**: Apply research quality filters at optimal stages
- **Real Data**: Works with actual arXiv d... | [
0.009552156552672386,
-0.009191424585878849,
-0.06518500298261642,
-0.025122590363025665,
0.0584055632352829,
-0.02418782189488411,
0.03074067458510399,
0.029107751324772835,
0.09199462831020355,
-0.04029691591858864,
0.045076657086610794,
0.06526631116867065,
0.08723599463701248,
-0.02959... |
bc6e5084-1a0d-5720-9f8c-c83f8929fb7a | /articles/product-quantization/ | Product Quantization for Vector Search | Product Quantization Benchmarks | article | false | Product Quantization for Vector Search > Product Quantization Benchmarks
These measurements are from 2023, taken around the Qdrant 1.2.0 release, and have not been repeated on current versions. They show how the compression level affects precision, search time, and indexing time. They are not a comparison with today's... | [
0.03745414689183235,
-0.007054801564663649,
-0.03165631741285324,
-0.019726894795894623,
0.059412457048892975,
-0.023312903940677643,
0.05741230398416519,
0.07400372624397278,
0.08235044777393341,
-0.052183598279953,
0.0421067476272583,
0.043570175766944885,
0.02262141928076744,
-0.0554363... |
bc935f27-c822-5130-b259-06e90ead2db6 | /documentation/examples/rag-chatbot-red-hat-openshift-haystack/ | Private Chatbot for Interactive Learning | Implementation > Indexing pipeline > Creating the embeddings and writing data to Qdrant | documentation | true | Private Chatbot for Interactive Learning > Implementation > Indexing pipeline > Creating the embeddings and writing data to Qdrant
The chunks are now ready to be converted into embeddings and stored in Qdrant. This is the part we hand over to a Haystack
pipeline. It uses `FastembedDocumentEmbedder`, pointed to our `BA... | [
0.024783065542578697,
-0.029737774282693863,
-0.04117043316364288,
-0.05464155972003937,
0.03071744367480278,
-0.06691327691078186,
0.03858940303325653,
0.04278967157006264,
0.02788059413433075,
-0.021394768729805946,
0.027399173006415367,
-0.009222866035997868,
0.0651850774884224,
-0.0485... |
bc9e6338-6753-5e02-aa47-0e8260ff6edb | /documentation/production-operations/predictable-search-latency/ | Configure Qdrant's Optimizer for Predictable Search Latency | Caveats | documentation | false | Configure Qdrant's Optimizer for Predictable Search Latency > Caveats
All 13 configurations ran against the same single-node Qdrant instance, one after another, so absolute latency numbers reflect that specific machine and shouldn't be read as general performance figures. The closed-loop search pattern also biases our... | [
0.05456018075346947,
-0.058816831558942795,
-0.07152827829122543,
-0.04361354559659958,
0.06238308921456337,
-0.04453761503100395,
0.04286395385861397,
0.009488486684858799,
0.10297715663909912,
-0.02891470491886139,
0.007231952156871557,
-0.010405289940536022,
0.052747778594493866,
-0.042... |
bca2ce69-f234-5094-a3f7-fe5390d22afd | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | Silent Settings Can Break Quality > Filtered Search | documentation | false | What to Check Before Tuning a Qdrant Collection > Silent Settings Can Break Quality > Filtered Search
Index every field you filter on. The cost of skipping one grows with collection size and query concurrency.
**[Payload indexes](/documentation/manage-data/indexing/#payload-index)** A healthy collection has a payload... | [
0.04169034585356712,
-0.025754490867257118,
-0.04971940442919731,
-0.02152717299759388,
0.06577207893133163,
-0.01846401020884514,
0.05860673263669014,
0.01676441915333271,
0.08228260278701782,
-0.03992605209350586,
0.04480423778295517,
0.04975653067231178,
0.04232625663280487,
-0.02954226... |
bcbeacf4-523c-5351-bec9-6bed1cdd809b | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-2/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 2: Training SPLADE on Modal | Parallel Hyperparameter Sweeps | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 2: Training SPLADE on Modal > Parallel Hyperparameter Sweeps
One of Modal's strengths is embarrassingly parallel workloads. Hyperparameter sweeps are a natural fit. `spawn()` launches one GPU per configuration:
```python
# Pseudocode: training and evaluate() ... | [
0.03538137301802635,
-0.021518107503652573,
-0.03795398026704788,
-0.050462741404771805,
0.06581076979637146,
-0.007967996411025524,
0.10746543109416962,
0.014220943674445152,
0.0705433115363121,
0.002066950546577573,
0.021929314360022545,
0.018564196303486824,
0.029563970863819122,
-0.011... |
bcc3a183-746b-505c-85d8-4dd1c4f628a4 | /course/essentials/day-1/pitstop-project/ | Project: Building a Semantic Search Engine | Setup | course | false | Project: Building a Semantic Search Engine > Setup
### Prerequisites
- Qdrant Cloud cluster (URL + API key)
- Python 3.9+ (or Colab)
- Packages: `qdrant-client`, `sentence-transformers`, `google.colab` (if using Colab)
### Models
- SentenceTransformer: `all-MiniLM-L6-v2` (384-dim)
*(You can try others in “Optio... | [
0.032319068908691406,
-0.024373037740588188,
-0.05941184610128403,
-0.020348718389868736,
0.08724337071180344,
-0.03515032306313515,
0.05258827656507492,
0.011886834166944027,
0.06441519409418106,
-0.042716484516859055,
0.03777417913079262,
0.011341423727571964,
0.054013557732105255,
-0.02... |
bccac566-091b-5b14-8802-5d24165672a4 | /documentation/data-management/chonkie/ | Chonkie | documentation | true | Chonkie
[Chonkie](https://github.com/chonkie-inc/chonkie) is a no-nonsense, ultra-light, and lightning-fast chunking library designed for RAG (Retrieval-Augmented Generation) applications.
Chonkie integrates seamlessly with Qdrant through the **QdrantHandshake** class, allowing you to chunk, embed, and store text dat... | [
0.037937700748443604,
-0.013948203064501286,
-0.05362851545214653,
-0.05517883598804474,
0.07067842036485672,
-0.038224782794713974,
0.04618425667285919,
0.031832776963710785,
0.032008614391088486,
-0.04388360306620598,
-0.004490731284022331,
0.008505182340741158,
0.05573218688368797,
-0.0... | |
bccc004b-b731-5333-8310-6f99b2a799ff | /documentation/edge/edge-vs-qdrant-cluster/ | Edge vs. Qdrant Cluster | API & Features | documentation | false | Edge vs. Qdrant Cluster > API & Features
How you talk to each option, and what you can do once connected.
| | Qdrant Edge | Qdrant Server |
| --- | --- | --- |
| **API** | In-process library API ([Python](https://pypi.org/project/qdrant-edge-py/) and [Rust](https://crates.io/crates/qdrant-edge) bindings) | REST and g... | [
0.039024222642183304,
-0.036236949265003204,
-0.04733920842409134,
-0.018964264541864395,
0.05498967319726944,
-0.05459341034293175,
0.06991470605134964,
0.025556126609444618,
0.08300851285457611,
-0.05715436860918999,
0.06504880636930466,
0.014377875253558159,
0.01021132618188858,
0.00342... |
bcd8b2ca-fbf4-5c51-bf74-d984a9d20ec5 | /documentation/search-tuning/hybrid-search/ | Hybrid Search in Qdrant | documentation | false | Hybrid Search in Qdrant

A search result can look plausible and still be wrong. Dense retrieval can return a document on the right topic but miss an exact identifier copied into ... | [
0.032756220549345016,
-0.04217631369829178,
-0.03203381225466728,
-0.05541118606925011,
0.07102049142122269,
-0.04777635261416435,
0.0738072544336319,
0.03830431029200554,
0.06236637383699417,
-0.04118713364005089,
0.02091127634048462,
0.05284442380070686,
0.049641989171504974,
0.003168314... | |
bce8274a-5faa-584e-a087-2ce7b353553d | /course/beginners/module-0/qdrant-cloud/ | Qdrant Setup | Qdrant Cloud Inference | course | false | Qdrant Setup > Qdrant Cloud Inference
This part is optional, but good to know it exists. Normally you turn text or images into vectors yourself before storing them. **[Cloud Inference](/cloud-inference/)** does that step for you inside Qdrant Cloud: you send raw text or images, and Qdrant creates the vectors and store... | [
0.04869476333260536,
-0.04345754161477089,
-0.005315190646797419,
-0.0651114210486412,
0.04652608558535576,
-0.010143755003809929,
0.06756211072206497,
0.031412433832883835,
0.05407183989882469,
-0.02288246527314186,
-0.0016071918653324246,
0.011774319224059582,
0.06935158371925354,
-0.021... |
bcffe9f1-f8d2-5e65-b022-8c5b031072b5 | /documentation/manage-data/quantization/ | Quantization | How to Choose the Right Quantization Method | documentation | false | Quantization > How to Choose the Right Quantization Method
Depending on your requirements for recall, compression, and distance metrics, consult this table for guidance:
| Compression | Method |
|-------------|-------------|
| 4 | Use 8-bit **TurboQuant**. In our benchmarks, the 8-bit TurboQuant encodi... | [
0.029003208503127098,
-0.037185654044151306,
-0.05048922449350357,
-0.04517253488302231,
0.04120418056845665,
0.005151853896677494,
0.05620924010872841,
0.040572650730609894,
0.1268095076084137,
-0.027828700840473175,
0.04350864142179489,
0.01627691090106964,
0.03309468924999237,
-0.014267... |
bd12f3de-cc16-5397-bfbf-8523715b9504 | /articles/vector-similarity-beyond-search/ | Vector Similarity: Going Beyond Full-Text Search | Diversity Search | article | true | Vector Similarity: Going Beyond Full-Text Search > Diversity Search
Even without a query vector, similarity between the stored points can improve an overall selection of items from the dataset.
The naive approach is to do [random sampling](/documentation/search/search/#random-sampling).
However, unless our dataset h... | [
0.07727548480033875,
-0.054845452308654785,
-0.061721719801425934,
-0.005620751064270735,
0.06311690807342529,
-0.024264590814709663,
0.08277467638254166,
0.023431790992617607,
0.07124585658311844,
-0.04692106693983078,
0.041147150099277496,
0.031598079949617386,
0.04774702340364456,
0.026... |
bd2e0f4e-c85b-5ccb-a474-1f4894302e62 | /documentation/overview/vector-search/ | Understanding Vector Search in Qdrant | The Representation Revolution | documentation | false | Understanding Vector Search in Qdrant > The Representation Revolution
The latest research in Machine Learning for NLP is heavily focused on training Deep Language Models. In this process, the neural network takes a large corpus of text as input and creates a mathematical representation of the words in the form of vect... | [
0.05111902579665184,
-0.04344768822193146,
-0.06658190488815308,
-0.036948610097169876,
0.06494605541229248,
-0.041800931096076965,
0.042431216686964035,
0.025249281898140907,
0.08684033155441284,
-0.02050129324197769,
0.04716244339942932,
0.04731801524758339,
0.05704501271247864,
-0.03532... |
bd3faaaf-562b-5688-b270-4f546904f698 | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | The Vision Language Model Foundation > Building on PaliGemma | course | false | How ColPali Models Work > The Vision Language Model Foundation > Building on PaliGemma
ColPali v1.3 is built on **PaliGemma-3B**, a Vision Language Model that combines two powerful components:
- **SigLIP-So400m** (Vision Encoder): Processes images into visual features
- **Gemma-2B** (Language Model): Contextualizes t... | [
0.022158971056342125,
-0.05079583823680878,
-0.0736599937081337,
-0.042010895907878876,
0.0758264809846878,
-0.00736123975366354,
0.0457073338329792,
0.02897132746875286,
0.02947702817618847,
-0.032941944897174835,
0.005595593247562647,
-0.01503126323223114,
0.048205021768808365,
-0.026881... |
bd56b824-71d1-50bb-a2b3-da92278eab79 | /course/essentials/day-3/hybrid-search/ | Hybrid Search and the Universal Query API | Universal Query API | course | true | Hybrid Search and the Universal Query API > Universal Query API
The Universal Query API was introduced in Qdrant 1.10. It consolidated all the other APIs in a single method and, most importantly for us, made it easier to build hybrid search pipelines.
### Pattern 1: Dense Retrieval → Sparse Reranking
Here is how the... | [
0.04455915093421936,
-0.052513159811496735,
-0.05427926406264305,
-0.049630485475063324,
0.07567249983549118,
-0.032173555344343185,
0.057334523648023605,
0.04094916954636574,
0.09934727102518082,
-0.03609127178788185,
0.019172366708517075,
0.05730060860514641,
0.05112135782837868,
-0.0145... |
bd606fc9-9bec-5ac4-a03b-449375bbe4de | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Experiments > Setup | article | false | Relevance Feedback in Qdrant > Experiments > Setup
Each triplet **retriever**, **feedback model**, **dataset** forms one experiment.
Datasets
A subset of BEIR (Information Retrieval benchmark):
MSMARCO (8.84mln documents)
SCIDOCS (25K documents)
Quora (523K documents)
FiQA-2018 (57K documents)
NFCo... | [
0.061709772795438766,
-0.009822693653404713,
-0.023413972929120064,
-0.06618907302618027,
0.05213186889886856,
-0.022383347153663635,
0.04912320896983147,
0.06671659648418427,
0.050337616354227066,
-0.031640924513339996,
0.017957540228962898,
0.015890328213572502,
0.07204090803861618,
-0.0... |
bd648b25-46d6-5307-9a40-c8f441f99f47 | /documentation/search-evaluation/retrieval-relevance/ | Measuring Retrieval Relevance | Using the Golden Set > Choosing the Right Metric | documentation | false | Measuring Retrieval Relevance > Using the Golden Set > Choosing the Right Metric
Which metric matters most depends on what your pipeline does with results:
| Scenario | Recommended Metric | Why |
|---|---|---|
| RAG pipeline (LLM reads top-k chunks) | `Recall@k` | The LLM can recover if a relevant doc is at position ... | [
0.012685446068644524,
-0.03520055115222931,
-0.04878607392311096,
-0.0103950509801507,
0.06844715774059296,
-0.013865606859326363,
0.051212336868047714,
0.047358188778162,
0.07914607971906662,
-0.03627017140388489,
-0.009554252028465271,
-0.017029134556651115,
0.048446934670209885,
-0.0299... |
bd6b4f85-13f0-51b3-acdf-81cfdca11b3c | /course/multi-vector-search/module-2/colpali-family/ | ColPali Family Overview | course | false | ColPali Family Overview
Module 2
The ColPali is not only the name of a model. Still, it is also often used to refer to an entire family of models that convert images and text into multi-vector representations, based on Vision Language Models.
Let's explore what the options are and which model to choose depending on ... | [
0.004525098484009504,
-0.017778296023607254,
-0.0451318696141243,
-0.0721002146601677,
0.07844122499227524,
-0.020662905648350716,
0.09919358789920807,
0.06050127372145653,
0.021030649542808533,
-0.013214650563895702,
0.03127715736627579,
0.018651694059371948,
0.06248673051595688,
-0.03379... | |
bd729dbb-9d04-54b5-83fd-d42ee3cbe5f8 | /documentation/tutorials-develop/code-search/ | Semantic Search for Code | Data preparation > Code to natural language conversion | documentation | true | Semantic Search for Code > Data preparation > Code to natural language conversion
Each programming language has its own syntax which is not a part of the natural
language. Thus, a general-purpose model probably does not understand the code
as is. We can, however, normalize the data by removing code specifics and
inclu... | [
0.06790581345558167,
-0.04099540039896965,
-0.03520850092172623,
-0.034812234342098236,
0.07027362287044525,
-0.02177027054131031,
0.039390552788972855,
-0.012147868052124977,
0.03702954947948456,
0.0007910840795375407,
0.0367569662630558,
0.025467853993177414,
0.10462071746587753,
-0.0327... |
bd735d3c-ea51-5ac4-9988-b320b6fbb617 | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | The Query Planner: Adaptive Strategy | course | false | Combining Vector Search and Filtering > The Query Planner: Adaptive Strategy
At query time, Qdrant uses a query planner to determine the appropriate strategy. This planning happens per segment and is based on filter cardinality, index availability, and thresholds like `full_scan_threshold`.
- **Filter matches many po... | [
0.03283439949154854,
-0.03370745852589607,
-0.03955240920186043,
-0.014976248145103455,
0.0601038821041584,
0.004878434352576733,
0.08689065277576447,
0.014079862274229527,
0.0768156424164772,
-0.0053311800584197044,
0.07480882853269577,
0.010858344845473766,
0.05945226177573204,
-0.019531... |
bd747e78-a2c1-5f54-a923-b30197c2bb43 | /documentation/tutorials-operations/data-streaming-kafka-qdrant/ | Kafka Streaming into Qdrant | Source Systems | documentation | false | Kafka Streaming into Qdrant > Source Systems
The architecture begins with the **source systems**, represented by MongoDB and Azure Blob Storage. These systems are vital for storing and managing raw data. MongoDB, a popular NoSQL database, is known for its flexibility in handling various data formats and its capability... | [
0.011247538961470127,
-0.03305363282561302,
-0.04299916326999664,
-0.04106437787413597,
0.07694219797849655,
-0.022009123116731644,
0.07671362161636353,
0.03849411383271217,
0.0389852337539196,
-0.015323713421821594,
0.022096673026680946,
-0.01340925320982933,
0.0503140427172184,
-0.012874... |
bd9152ae-8b56-5470-b897-2699804a4309 | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Payloads (Metadata) > Payload Types > Data Structures | course | false | Points, Vectors and Payloads > Payloads (Metadata) > Payload Types > Data Structures
Any of the above types can be stored within more complex structures:
* **Arrays:** A field can contain multiple values of the same type. A filter will succeed if *at least one* value in the array meets the condition.
* *Examp... | [
0.0366324856877327,
-0.011174583807587624,
-0.04980972036719322,
-0.03053787723183632,
0.0247929859906435,
-0.03577956557273865,
0.04199955612421036,
0.025695225223898888,
0.05686011537909508,
-0.04890063405036926,
0.03652990981936455,
0.01786143146455288,
0.07210032641887665,
-0.000714774... |
bd94bfa9-4846-52e4-ad42-edc1ec02443b | /documentation/embeddings/nvidia/ | NVIDIA | Setup | documentation | true | NVIDIA > Setup
Install the OpenAI SDK and the Qdrant client. The NVIDIA API is OpenAI-compatible, and NVIDIA's own Python examples use the OpenAI SDK with NVIDIA's base URL. NVIDIA has no TypeScript SDK, so the TypeScript examples call the REST API with `fetch`.
- Python: `pip install openai qdrant-client`
- TypeScri... | [
0.025880249217152596,
-0.05324722081422806,
-0.009255073964595795,
-0.03602636978030205,
0.07507200539112091,
-0.038302481174468994,
0.07244271039962769,
0.05263557657599449,
0.04373062029480934,
-0.0337948352098465,
0.054718267172575,
0.0028894825372844934,
0.04995977506041527,
-0.0440469... |
bd9b7028-6e1b-5bf3-9243-308b101e7807 | /documentation/production-operations/access-control/ | Data Privacy with Qdrant's Role-Based Access Control (RBAC) | Vector Database Security: An Overview | documentation | false | Data Privacy with Qdrant's Role-Based Access Control (RBAC) > Vector Database Security: An Overview
Vector databases are often unsecured by default to facilitate rapid prototyping and experimentation. This approach allows developers to quickly ingest data, build vector representations, and test similarity search algor... | [
0.02746846154332161,
-0.05654897540807724,
-0.0559069849550724,
-0.04552767425775528,
0.03372823819518089,
-0.076716847717762,
0.05645187571644783,
0.049932003021240234,
0.05722777917981148,
0.004987763240933418,
-0.009084156714379787,
0.05312133580446243,
0.07344289124011993,
-0.044256795... |
bda0c9e7-2ca8-59f1-99b4-65de5702c0eb | /articles/late-interaction-models/ | Late Interaction Retrieval with Dense Token Embeddings | Using Output Token Embeddings for Multi-Vector Representations | article | false | Late Interaction Retrieval with Dense Token Embeddings > Using Output Token Embeddings for Multi-Vector Representations
We often overlook the output token embeddings, but the fact is—they also serve as multi-vector representations of the input text. So, why not explore their use in a multi-vector retrieval model, simi... | [
0.051819488406181335,
-0.023481393232941628,
-0.04068087786436081,
-0.07311277836561203,
0.09541010856628418,
-0.06639832258224487,
0.059405114501714706,
0.05473041161894798,
0.06797920167446136,
-0.014357812702655792,
0.03574942797422409,
0.024842187762260437,
0.04616609215736389,
-0.0088... |
bda6e516-c261-516c-91e9-b628d4345cdd | /documentation/search/search/ | Search | Query API | documentation | true | Search > Query API
*Available as of v1.10.0*
Qdrant provides a single interface for all kinds of search and exploration requests - the `Query API`.
Here is a reference list of what kind of queries you can perform with the `Query API` in Qdrant:
Depending on the `query` parameter, Qdrant might prefer different strate... | [
0.046991027891635895,
-0.043492160737514496,
-0.04316271096467972,
-0.0365610346198082,
0.07903528958559036,
-0.038320865482091904,
0.06134716421365738,
0.03191147744655609,
0.07729731500148773,
-0.04051503911614418,
0.06551217287778854,
0.02871738187968731,
0.049239035695791245,
-0.027294... |
bdb9e8e6-cf41-5ffe-a667-d61317505427 | /documentation/tutorials-operations/secure-qdrant/ | Secure a Self-Hosted Qdrant Instance | What's Next | documentation | false | Secure a Self-Hosted Qdrant Instance > What's Next
Your instance now has TLS encryption, API key authentication, a read-only key for query consumers, and collection-scoped JWT tokens. For production deployments, also consider:
- [Network Bind](/documentation/security/#network-bind) — restrict which network interfaces... | [
0.04406891390681267,
-0.058382607996463776,
-0.02768121473491192,
-0.067101389169693,
0.010299719870090485,
-0.04446497932076454,
0.05836388096213341,
0.03162701800465584,
0.10548178106546402,
-0.002483634278178215,
0.03853706270456314,
-0.0011992178624495864,
0.05102278292179108,
-0.04387... |
bdbd8f1c-64d8-50ae-8936-60a8f7edd1c8 | /documentation/data-management/fluvio/ | InfinyOn Fluvio | documentation | true | InfinyOn Fluvio

[InfinyOn Fluvio](https://www.fluvio.io/) is an open-source platform written in Rust for high speed, real-time data processing. It is cloud native, designed to work with any infrastructure type, from bare metal hardware to container... | [
0.04213564842939377,
-0.04531637951731682,
-0.018458155915141106,
-0.0654522180557251,
0.04301860183477402,
-0.037665095180273056,
0.0741724818944931,
0.06140045076608658,
0.05376860126852989,
-0.049075182527303696,
0.004269730299711227,
0.051798488944768906,
0.030431313440203667,
0.008471... | |
bdc38ac0-dd46-5aa2-afd8-78a839873b92 | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 1: Application-Level Dual-Write > Architecture | documentation | false | Keeping Postgres and Qdrant in Sync > Tier 1: Application-Level Dual-Write > Architecture
Every CRUD endpoint writes to Postgres first, then to Qdrant, in the same request handler. If the Qdrant write fails, the error is logged but the request succeeds — Postgres is the source of truth, and a reconciliation job can fi... | [
0.022660288959741592,
-0.05918257683515549,
-0.015117239207029343,
-0.01000208593904972,
0.004969181027263403,
-0.017078109085559845,
0.06497702747583389,
0.05472930520772934,
0.05878092348575592,
0.00996053870767355,
0.03070598840713501,
0.03143702447414398,
0.05617895722389221,
-0.010756... |
bdc5f4e2-c63d-5783-b9e6-cc6cff4a7b91 | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | How We Tested the Final Product > First... Model Testing | article | true | Introducing Gridstore: Qdrant's Custom Key-Value Store > How We Tested the Final Product > First... Model Testing
Gridstore can be tested efficiently using model testing, which compares its behavior to a simple in-memory hash map. Since Gridstore should function like a persisted hash map, this method quickly detects i... | [
0.0471370592713356,
-0.02504810132086277,
-0.04276647791266441,
-0.03416862338781357,
0.03557908535003662,
-0.045622266829013824,
0.08011409640312195,
0.01091521605849266,
0.06065917760133743,
-0.0064138974994421005,
0.03684602677822113,
0.004512776620686054,
0.00004084328975295648,
-0.034... |
bde1ca5e-0109-5075-b665-a6bb32d3839d | /course/essentials/day-1/movie-search-system/ | Demo: Semantic Movie Search | What You'll Build | course | false | Demo: Semantic Movie Search > What You'll Build
A semantic search engine that can:
- **Understand meaning**: Search for "time travel and family relationships" and find *Interstellar*
- **Compare chunking strategies**: See how fixed-size, sentence-based, and semantic chunking affect search quality
- **Filter intellige... | [
0.04587335139513016,
-0.029694652184844017,
-0.07229951024055481,
0.00402476591989398,
0.06021175906062126,
-0.023831218481063843,
0.039092209190130234,
0.006634930148720741,
0.05423885956406593,
-0.012659088708460331,
0.052477240562438965,
0.014537437818944454,
0.07936464250087738,
-0.030... |
bde7b470-4958-50d2-8348-193de7d2f976 | /articles/neural-search-tutorial/ | Neural Search 101: A Complete Guide and Step-by-Step Tutorial | Step-by-step neural search tutorial using Qdrant | article | false | Neural Search 101: A Complete Guide and Step-by-Step Tutorial > Step-by-step neural search tutorial using Qdrant
With all that said, let's make our neural network search.
As an example, I decided to make a search for startups by their description.
In this demo, we will see the cases when text search works better and t... | [
0.010177952237427235,
-0.09155429899692535,
-0.04782654717564583,
-0.04157474264502525,
0.05268285050988197,
-0.01931305229663849,
0.04079617187380791,
0.04841919243335724,
0.0760674998164177,
0.0047290814109146595,
0.017740173265337944,
0.05989545211195946,
0.07969851046800613,
-0.0506769... |
bdf3dc43-7587-5209-b101-42f1706b164e | /documentation/tutorials-build-essentials/agentic-rag-langgraph/ | Agentic RAG with LangGraph | documentation | false | Agentic RAG with LangGraph
| Time: 45 min | Level: Intermediate | Output: Python agent |
| --- | --- | --- |
Traditional Retrieval-Augmented Generation (RAG) systems follow a straightforward path: query → retrieve → generate. Sure, this works well for many scenarios. But let’s face it—this linear approach often strug... | [
-0.00528218736872077,
-0.026665616780519485,
-0.04711621627211571,
-0.030807558447122574,
0.10064774006605148,
-0.08756887167692184,
0.029301298782229424,
0.04758062586188316,
0.07357736676931381,
-0.05892399698495865,
0.03980129212141037,
0.04523496702313423,
0.06851617246866226,
-0.03695... | |
bdf8d5ca-54d3-5a5d-826b-3087181482fc | /documentation/upgrades/ | Upgrades | documentation | false | Upgrades
If you are several versions behind, multiple updates might be required to reach the latest version. When upgrading Qdrant, upgrade to the latest patch version of each intermediate minor version first. For example, if you are running version 1.15 and want to upgrade to 1.17, you must first upgrade all cluster ... | [
0.014943254180252552,
-0.04477139562368393,
-0.05391605198383331,
-0.02450314350426197,
0.06100816652178764,
-0.03780572488903999,
0.030340176075696945,
0.020472392439842224,
0.05554112046957016,
-0.04127427935600281,
0.018945876508951187,
0.02893710695207119,
0.0517798475921154,
-0.055248... | |
be0bc024-b4fc-54dd-befe-7fd8ed502d27 | /course/beginners/module-1/distance-metrics/ | Comparing Meaning: Distance Metrics | Try It Yourself: Compare Cosine Scores | course | true | Comparing Meaning: Distance Metrics > Try It Yourself: Compare Cosine Scores
Reuse the embedding snippet from [How It Works: Embeddings](/course/beginners/module-1/embeddings/) to embed three query/document pairs, then score each pair with cosine similarity, using the formula above implemented directly with NumPy.
Th... | [
0.0655566155910492,
-0.0387054868042469,
-0.040342651307582855,
-0.016125725582242012,
0.08059465885162354,
-0.0006889348151162267,
0.02422340214252472,
0.018855882808566093,
0.07162383198738098,
-0.031380750238895416,
0.05020860210061073,
0.019705815240740776,
0.047716185450553894,
0.0030... |
be1eac22-cf96-5015-91fb-32f5d7a5c22e | /documentation/edge/edge-api/reading-data/ | Reading Data | count | documentation | true | Reading Data > count
Counts the points matching a filter.
```python
def count(self, count: CountRequest) -> int
```
**Returns** the number of matching points.
| Parameter | Type | Description |
| --- | --- | --- |
| `filter` | `Filter` | Conditions the counted points must satisfy. Omit to count every point. |
| `ex... | [
0.018719851970672607,
-0.03706474229693413,
-0.057853516191244125,
-0.050410401076078415,
0.05045251175761223,
0.008080531843006611,
0.029126716777682304,
0.05871974676847458,
0.09932557493448257,
-0.0031094299629330635,
0.03366118296980858,
0.02831561304628849,
0.08337712287902832,
-0.039... |
be22d287-8096-5805-813e-5ceba6c3930e | /documentation/embeddings/nomic/ | Nomic | Embed Documents | documentation | true | Nomic > Embed Documents
Set `task_type` to `search_document` for the texts you store. The response lists embeddings in input order, so this example uses each input's position as the point ID:
```python
documents = [
"Qdrant is a vector search engine.",
"Nomic Embed models turn text into dense vectors.",
"... | [
0.031462412327528,
-0.04362383112311363,
-0.027496639639139175,
-0.0300751980394125,
0.06424811482429504,
-0.06419294327497482,
0.052799247205257416,
0.0313091017305851,
0.06656265258789062,
-0.0016426444053649902,
0.02940468117594719,
0.038315970450639725,
0.03647059574723244,
-0.02172981... |
be2ea276-7621-5afd-8770-a2c0bb09c8b9 | /documentation/tutorials-operations/incremental-embedding-updates/ | Incremental Embedding Updates | Syncing with Documentation Changes > Cases 3 and 4: ID Is Not Present in the Collection | documentation | true | Incremental Embedding Updates > Syncing with Documentation Changes > Cases 3 and 4: ID Is Not Present in the Collection
Six IDs are unknown to the collection, but an unknown ID does not necessarily mean new content. When a page moves as-is, every chunk on it gets a new address (a new ID), while the text stays exactly ... | [
0.03864932432770729,
-0.022238560020923615,
-0.06683190912008286,
-0.024962009862065315,
0.03588205203413963,
-0.0015223611844703555,
0.015628769993782043,
0.01731938123703003,
0.08321689069271088,
-0.012712701223790646,
0.010420314036309719,
0.04749395325779915,
0.022836338728666306,
-0.0... |
be353727-a5cf-5e84-8cc1-6f2595e8b4cb | /documentation/edge/edge-quickstart/ | Quickstart | Create a Storage Directory | documentation | true | Quickstart > Create a Storage Directory
## Install Qdrant Edge
First, install the [Python Bindings for Qdrant Edge](https://pypi.org/project/qdrant-edge-py/) or the [Rust crate](https://crates.io/crates/qdrant-edge).
A Qdrant Edge Shard stores its data in a local directory on disk. Create the directory if it doesn't... | [
0.040744930505752563,
-0.03413417562842369,
-0.02069605514407158,
-0.013486017473042011,
0.06040547788143158,
-0.07048917561769485,
0.057350169867277145,
0.030650807544589043,
0.0937403067946434,
-0.048582397401332855,
0.04052504897117615,
-0.007054327987134457,
0.07007693499326706,
-0.005... |
be461a14-5e8a-5e46-a166-fd645340b47f | /documentation/tutorials-build-essentials/agentic-rag-camelai-discord/ | Discord RAG Bot | Step 3: Ingest the Documentation | documentation | true | Discord RAG Bot > Step 3: Ingest the Documentation
All source entries must be absolute URLs. Relative paths such as `/documentation/search/filtering` do not identify a web page on their own.
```python
QDRANT_URLS = [
"https://qdrant.tech/documentation/overview/",
"https://qdrant.tech/documentation/installatio... | [
0.02829155884683132,
-0.030995279550552368,
-0.04923763871192932,
-0.010248123668134212,
0.05295445770025253,
-0.02253604307770729,
0.023266812786459923,
0.0578712560236454,
0.028880489990115166,
-0.029090022668242455,
0.03602922335267067,
0.005843066144734621,
0.01969889923930168,
-0.0357... |
be61543d-1b41-515f-8ae3-94901eed2d20 | /documentation/upgrades/ | Upgrades | Docker | documentation | true | Upgrades > Docker
If you run Qdrant using Docker, you can upgrade to a new version by pulling the new image and restarting the Qdrant containers one after another. For example:
```bash
docker pull qdrant/qdrant
docker stop qdrant
docker run --name qdrant -d -p 6333:6333 \
-v $(pwd)/path/to/data:/qdrant/storage \
... | [
0.031421810388565063,
-0.06607518345117569,
-0.029659206047654152,
-0.03587337210774422,
0.04177510365843773,
-0.04378873109817505,
0.055128827691078186,
0.002795339096337557,
0.05195334181189537,
-0.008070282638072968,
0.011555508710443974,
0.014825791120529175,
0.06553860008716583,
-0.03... |
be876bc7-216f-590f-aa57-66423fd32d37 | /documentation/hybrid-cloud/hybrid-cloud-setup/ | Setup Hybrid Cloud | Prerequisites > CLI tools | documentation | false | Setup Hybrid Cloud > Prerequisites > CLI tools
During the onboarding, you will need to deploy the Qdrant Cloud Agent using Helm. Make sure you have the following tools installed:
* [kubectl](https://kubernetes.io/docs/tasks/tools/install-kubectl/)
* [helm](https://helm.sh/docs/intro/install/)
You will need to have a... | [
0.01537478156387806,
-0.051607221364974976,
-0.039031077176332474,
-0.032525431364774704,
0.06994951516389847,
-0.05497667193412781,
0.046651411801576614,
0.03748227655887604,
0.03508267551660538,
-0.019054288044571877,
0.03348309546709061,
0.008607756346464157,
0.04472718387842178,
-0.033... |
beb8ca40-6f64-5802-bea1-1856c9bcb2f2 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | What Does it Take to Run Search in Production? | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > What Does it Take to Run Search in Production?
A mid-sized e-commerce company launched a vector search pilot to improve product discovery. During testing, everything ran smoothly. But in production, their queries began failing intermittently: memory errors, dis... | [
0.010483693331480026,
-0.04809179902076721,
-0.09032224118709564,
-0.040861908346414566,
0.055689990520477295,
-0.03565989062190056,
0.028884345665574074,
0.027958355844020844,
0.09768637269735336,
-0.003838959615677595,
0.0026480250526219606,
0.0015690161380916834,
0.034282486885786057,
-... |
becacfe3-afe7-55de-abb8-b859451aa9e4 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-5/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product | Acknowledgements | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product > Acknowledgements
Thanks to all the people who made this series possible. It started with Kumar Shivendu's insight that the industry lacked good resources on fine-tuning retrieval models on your own dataset to outperform popular mo... | [
0.04191672429442406,
-0.07044567167758942,
-0.029243052005767822,
-0.01277939137071371,
0.01904452033340931,
-0.05653929337859154,
0.08690139651298523,
0.020946985110640526,
0.04504852741956711,
-0.015376318246126175,
0.035112373530864716,
0.03585889935493469,
0.04519221931695938,
-0.06552... |
bed75e36-cd11-5814-9eed-8fb1a5a4524f | /documentation/search/search/ | Search | Search API > Filtering Results by Score | documentation | false | Search > Search API > Filtering Results by Score
In addition to payload filtering, it might be useful to filter out results with a low similarity score.
For example, if you know the minimal acceptance score for your model and do not want any results which are less similar than the threshold.
In this case, you can use ... | [
0.05818585306406021,
-0.05071881040930748,
-0.033997517079114914,
-0.01296283584088087,
0.054178956896066666,
0.002506071235984564,
0.046065159142017365,
0.0401095412671566,
0.07807062566280365,
-0.03313590958714485,
0.054402511566877365,
0.036792654544115067,
0.10570040345191956,
0.008350... |
bed7bd5b-e6b5-52a0-887d-eb5080dbcd3f | /articles/triplet-loss/ | Advanced Introduction to Triplet Loss | Conclusion | article | false | Advanced Introduction to Triplet Loss > Conclusion
I mentioned that Triplet Loss is different from Contrastive Loss not only mathematically but also in its sample selection strategies, and I implemented the batch-all strategy for online triplet mining in this post
efficiently by using several tricks.
There are other ... | [
0.043638676404953,
-0.06732679903507233,
-0.02932370826601982,
-0.051291368901729584,
0.04644422605633736,
0.018162794411182404,
0.0411820262670517,
0.013588966801762581,
0.06702862679958344,
-0.02398049272596836,
0.056025680154561996,
0.0045969136990606785,
0.020260032266378403,
0.0052245... |
bed8290d-320d-5a9a-9261-815ea1eff0a3 | /documentation/tutorials-operations/secure-qdrant/ | Secure a Self-Hosted Qdrant Instance | Step 1: Start an Unsecured Instance | documentation | true | Secure a Self-Hosted Qdrant Instance > Step 1: Start an Unsecured Instance
Start Qdrant using the [standard Docker Compose setup](/documentation/installation/#docker-compose). Create a `docker-compose.yml` file:
```yaml
services:
qdrant:
image: qdrant/qdrant
ports:
- "6333:6333"
- "6334:6334"
... | [
0.050211839377880096,
-0.04617920517921448,
-0.006194631103426218,
-0.043005432933568954,
0.03531155362725258,
-0.06016827002167702,
0.06708059459924698,
0.036645252257585526,
0.05717327818274498,
-0.02975071780383587,
0.02357431687414646,
0.021721230819821358,
0.06032544746994972,
-0.0673... |
bedfc4a3-a245-5e2a-9806-72df43ed671b | /documentation/tutorials-search-engineering/branch-aware-search/ | Branch-Aware Search | Searching a Branch | documentation | true | Branch-Aware Search > Searching a Branch
`lookup` resolves one known path; a search ranks the whole corpus by relevance. It's the same visibility filter, passed to a semantic query instead of a path scroll:
```python
def search(query, branch, ancestry, limit=5):
return client.query_points(
collection_name... | [
0.03288249671459198,
-0.06136593222618103,
-0.06076304614543915,
-0.049390003085136414,
0.09786427766084671,
-0.019220823422074318,
0.05117960274219513,
0.010637922212481499,
0.05246575176715851,
-0.025439931079745293,
0.020627351477742195,
0.06176289916038513,
0.0610816553235054,
0.005589... |
bee59ad4-1613-58f7-b2c9-648cb0b81b26 | /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
Tied scores are more common at low k. Averaged over SciFact's queries, 12.5% of default RRF's top 10 results share a score with the result next to them, against 2.8% at k=61 and none under DBSF. Fusion sorts on score alone, so a tied group comes back... | [
0.018805496394634247,
-0.02437576651573181,
-0.046505872160196304,
-0.04922570660710335,
0.05447512865066528,
-0.057496797293424606,
0.06600488722324371,
0.045710135251283646,
0.09358751028776169,
-0.0518517829477787,
0.051729753613471985,
0.02377888560295105,
0.020261162891983986,
-0.0093... |
beecdcce-8987-5ab9-bad7-6db5b8001a85 | /documentation/private-cloud/changelog/ | Changelog | 1.9.2 (2025-11-18) | documentation | false | Changelog > 1.9.2 (2025-11-18)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.20.0 |
| operator | 2.8.3 |
| qdrant-cluster-manager | v0.3.9 |
| qdrant-cluster-exporter | 1.7.2 |
* Qdrant 1.16 improvements | [
0.05138087272644043,
-0.03481394425034523,
-0.04834727942943573,
-0.02352770045399666,
0.04056793451309204,
-0.05225465074181557,
0.059278275817632675,
0.0337364487349987,
0.03732338175177574,
-0.03469708189368248,
0.03128848224878311,
0.03649887070059776,
0.05364716053009033,
-0.062065098... |
beee718b-19d6-5441-9c38-a7fb5025160f | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Search > My hybrid search results aren't relevant. Where do I start debugging? | documentation | false | Qdrant Fundamentals > Search > My hybrid search results aren't relevant. Where do I start debugging?
Work through these in order:
1. **Check lexical text processing.** Poor BM25 results are often a tokenization issue. For non-English text, configure language-specific stemming and stopwords on the [full-text index](/d... | [
0.0429694801568985,
-0.058645691722631454,
-0.05210001394152641,
-0.03858066350221634,
0.07646941393613815,
-0.04373352974653244,
0.028736108914017677,
0.004044169560074806,
0.05476435646414757,
-0.04190633445978165,
0.030516814440488815,
0.01921658031642437,
0.03669912740588188,
-0.025534... |
befa8e9d-5181-507c-b624-52fa89df907e | /documentation/tutorials-build-essentials/question-answering-langchain/ | Question Answering with LangChain and Qdrant | How to Implement Question Answering with LangChain and Qdrant > Step 3: Setting up the retrieval chain | documentation | true | Question Answering with LangChain and Qdrant > How to Implement Question Answering with LangChain and Qdrant > Step 3: Setting up the retrieval chain
With the knowledge base in place, the only thing left is to combine the retriever with a chat model. [`init_chat_model`](https://docs.langchain.com/oss/python/langchain/... | [
0.004951481241732836,
-0.031454574316740036,
-0.020360903814435005,
-0.014093782752752304,
0.05920913815498352,
-0.053636062890291214,
0.06498941034078598,
0.02033628523349762,
0.02844003029167652,
-0.014632203616201878,
0.017289377748966217,
-0.00450357748195529,
0.06025295332074165,
-0.0... |
befed548-d8b0-5203-a96d-29d73db130f4 | /course/essentials/day-1/chunking-strategies/ | Text Chunking Strategies | Chunking Strategies: The Shape Matters > 6. Semantic-Aware Chunking | course | false | Text Chunking Strategies > Chunking Strategies: The Shape Matters > 6. Semantic-Aware Chunking
The trade-off is computational cost. You're embedding the full document upfront just to decide where to split it - before you even store anything. It's slower and more expensive, but each chunk carries coherent ideas.
**Pro... | [
0.0006131760310381651,
-0.03900950402021408,
-0.06184694170951843,
-0.04712831228971481,
0.008657913655042648,
-0.02413996495306492,
0.038098063319921494,
-0.010050160810351372,
0.05152048543095589,
-0.03877348080277443,
0.019561629742383957,
0.0014096517115831375,
0.0781111940741539,
-0.0... |
bf14d01c-c004-575d-a776-ff620635dc7c | /articles/turboquant-quantization/ | TurboQuant in Qdrant | article | false | TurboQuant in Qdrant
If you run production vector workloads, you already know the compression ladder in Qdrant: float32 is the baseline, **Scalar Quantization (SQ)** compresses vectors by 4x with almost no recall hit, and **Binary Quantization (BQ)** packs vectors at 16x or 32x.
Qdrant 1.18 ships **TurboQuant**, a ne... | [
0.038660675287246704,
-0.029783902689814568,
-0.053140394389629364,
-0.055443938821554184,
0.01416171994060278,
0.0028719317633658648,
0.04773887246847153,
0.03805579990148544,
0.09705153852701187,
-0.030039213597774506,
0.03903387486934662,
0.0039765783585608006,
0.04013252630829811,
-0.0... | |
bf2c5ae8-c5a0-5fd9-a8d8-bb1ad54bc0aa | /articles/filtered-vector-search-acorn/ | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN | Double Filters: The Intersection Gap | article | false | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN > Double Filters: The Intersection Gap
The same benchmark at `hnsw_ef=64`, now with an `AND` filter over two keyword fields.
| Filter (selectivity) | Plain graph + ACORN | Filterable HNSW | Planner + ACORN |
|---|---|---|---|
| Two keywords (4%) | 95.2% @... | [
0.042072590440511703,
-0.056166619062423706,
-0.06249621883034706,
-0.01873711124062538,
0.08887889236211777,
-0.004455041140317917,
0.04793977737426758,
0.03597187623381615,
0.05019296333193779,
-0.02363821491599083,
0.04046041518449783,
0.04370884597301483,
0.05402849614620209,
-0.009672... |
bf2c8186-2b93-5cbf-8ca2-e5e10acd7ff7 | /documentation/ops-configuration/configuration/ | Configuration | Loading Order and Priority | documentation | false | Configuration > Loading Order and Priority
During startup, Qdrant merges multiple configuration sources into a single effective configuration. The loading order is as follows (from least to most significant):
1. Embedded default configuration
2. `config/config.yaml`
3. `config/{RUN_MODE}.yaml`
4. `config/local.yaml`
... | [
0.046189047396183014,
-0.06193166971206665,
-0.03434191644191742,
-0.03103756532073021,
0.08735202252864838,
-0.04585585743188858,
0.04250720888376236,
0.0435328371822834,
0.06324756890535355,
-0.0242744293063879,
0.006582183763384819,
0.016157228499650955,
0.03968510404229164,
-0.03305422... |
bf35af02-6e89-5049-bd8d-76befb695d78 | /documentation/cloud-quickstart/ | Cloud Quickstart | What's Next? | documentation | false | Cloud Quickstart > What's Next?
- Explore [filtering](/documentation/search/filtering/) to combine semantic search with structured queries
- Learn about [collections](/documentation/manage-data/collections/) and advanced configuration options
- Check out more [examples and tutorials](/documentation/tutorials-lp-overvi... | [
0.009118849411606789,
-0.029671255499124527,
-0.05039586126804352,
-0.04019264504313469,
0.05818798393011093,
-0.012092316523194313,
0.021461544558405876,
-0.010123046115040779,
0.06761214137077332,
-0.033747777342796326,
0.04101824015378952,
0.035818979144096375,
0.045705776661634445,
-0.... |
bf38a0ac-b56f-5b2b-ad1d-084699f2a578 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Migrating | documentation | false | Memory Tiers > Migrating
When migrating from a pre-1.19 version to a newer version, Qdrant doesn't automatically convert any [legacy settings](#legacy-settings) that control memory placement to the new `memory` setting. The legacy settings have only been deprecated, not removed, so your existing settings remain workin... | [
0.03877707198262215,
-0.05165577307343483,
-0.0029640253633260727,
-0.028456078842282295,
0.04425957053899765,
-0.04232724383473396,
0.012728255242109299,
0.02869855985045433,
0.06982724368572235,
-0.05221640318632126,
0.024705670773983,
0.012632598169147968,
0.06379767507314682,
-0.013776... |
bf40702f-3e6a-54ad-81e4-aaa8cd2c3657 | /articles/distance-based-exploration/ | Data Exploration with Qdrant's Distance Matrix API | Dimensionality Reduction | article | false | Data Exploration with Qdrant's Distance Matrix API > Dimensionality Reduction
An interactive version of this plot is available in the Qdrant Web UI. UMAP and t-SNE use the server's distance matrix. PCA retrieves raw vectors. The Web UI also supports coloring points by a payload field and filtering.
UMAP isn't the onl... | [
0.0727785974740982,
-0.054039984941482544,
-0.028737736865878105,
-0.03656240552663803,
0.07902447879314423,
-0.027529744431376457,
0.05254830792546272,
0.07330227643251419,
0.09243731200695038,
-0.033492859452962875,
0.05069328099489212,
0.023187408223748207,
0.030151665210723877,
-0.0211... |
bf6875ee-1d7c-5265-bce1-217cf73cb557 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Building a Concept Vocabulary > The "bajo" Problem | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Building a Concept Vocabulary > The "bajo" Problem
Our first, uncapped attempt produced a few clusters of several hundred words, a little too many. The culprit is polysemy: Spanish *"bajo"* means *low*, *bass*, *short*, and *under*; each of those En... | [
0.047839730978012085,
-0.01813839003443718,
-0.0505935437977314,
-0.05281661078333855,
0.08966951817274094,
-0.07630318403244019,
0.03064359724521637,
0.02575564943253994,
0.07611536979675293,
-0.04222238436341286,
0.027333637699484825,
0.02289765141904354,
0.07992058247327805,
-0.02505621... |
bf86b8ca-1c4c-5584-b4f2-aa925883c32d | /documentation/cloud-pricing-payments/ | Billing & Payments | documentation | false | Billing & Payments
Qdrant database clusters in Qdrant Cloud are priced based on CPU, memory, and disk storage usage. To get a clearer idea for the pricing structure, based on the amounts of vectors you want to store, please use our [Pricing Calculator](https://cloud.qdrant.io/calculator). | [
0.014058015309274197,
-0.019654983654618263,
-0.03515907749533653,
-0.052775703370571136,
0.01690312661230564,
-0.025538083165884018,
0.08075711876153946,
0.06340485066175461,
0.11364168673753738,
-0.054823897778987885,
0.03439417481422424,
-0.0010721104918047786,
0.04972344636917114,
-0.0... | |
bf87bd07-8823-5af2-a397-25d8c3194576 | /documentation/ops-optimization/ | Optimization | documentation | false | Optimization
These pages cover strategies and internal mechanisms for improving search performance, reducing memory usage, managing how Qdrant organizes data on disk, and troubleshooting read-write contention.
## Optimize Performance
[Optimize Performance](/documentation/ops-optimization/optimize/) walks through thr... | [
0.030670365318655968,
-0.04505521431565285,
-0.04017714411020279,
-0.02271435596048832,
0.07842393964529037,
-0.019062362611293793,
0.04189486801624298,
0.0018042814917862415,
0.08262863755226135,
-0.015865115448832512,
0.0031378595158457756,
-0.00505408737808466,
0.022206395864486694,
-0.... | |
bf8d513a-0329-5685-9d29-66655b398848 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-1/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 1: Why Sparse Embeddings Beat BM25 | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 1: Why Sparse Embeddings Beat BM25
*This is Part 1 of a 5-part tutorial on fine-tuning sparse embeddings for e-commerce search. We'll go from "why bother?" to a production system that beats BM25 by 17%. This part is theory-oriented: it explains the concepts, a... | [
0.030425459146499634,
-0.05895542725920677,
-0.06024094671010971,
-0.071903757750988,
0.055636271834373474,
-0.019317662343382835,
0.06588256359100342,
0.021754661574959755,
0.0790741890668869,
-0.03459418937563896,
0.03434717655181885,
0.029026944190263748,
0.07697638124227524,
-0.0463285... | |
bf8fc171-c0ef-5dc4-a38b-c8837998bd8c | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Qdrant Adds > Per-Coordinate Calibration (Anisotropy Compensation) | article | false | TurboQuant in Qdrant > What Qdrant Adds > Per-Coordinate Calibration (Anisotropy Compensation)
Truly isotropic data matches the theoretical Gaussian quantiles, the formula collapses to `(shift=0, scale=1)`, and the encoded vector is bit-identical to vanilla TurboQuant. So the `(shift, scale)` correction never degrades... | [
0.06451985985040665,
-0.02823115885257721,
-0.03264294192194939,
-0.05127115547657013,
0.027543699368834496,
0.027924908325076103,
0.05689426511526108,
0.02733863703906536,
0.06525945663452148,
-0.007077347487211227,
0.03640977293252945,
0.0037327497266232967,
0.07141270488500595,
-0.01605... |
bf9cd988-9737-517c-bfe3-9de40f8d7a6c | /documentation/production-operations/access-control/ | Data Privacy with Qdrant's Role-Based Access Control (RBAC) | How Qdrant Handles Data Privacy and Security | documentation | false | Data Privacy with Qdrant's Role-Based Access Control (RBAC) > How Qdrant Handles Data Privacy and Security
One of the cornerstones of our design choices at Qdrant has been the focus on security features. We have built in a range of features keeping the enterprise user in mind, which allow building of granular access c... | [
0.014134124852716923,
-0.017788182944059372,
-0.05362647399306297,
-0.042138002812862396,
0.04704658314585686,
-0.056436844170093536,
0.07869649678468704,
0.048876967281103134,
0.05497628450393677,
-0.022381383925676346,
0.005687411408871412,
0.024464938789606094,
0.08614522963762283,
-0.0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.