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 |
|---|---|---|---|---|---|---|---|
d3e2c210-87e3-5efd-b699-bcd07318f02d | /articles/what-is-a-vector-database/ | What is a Vector Database? | Hybrid Search > How to Use Hybrid Search in Qdrant | article | true | What is a Vector Database? > Hybrid Search > How to Use Hybrid Search in Qdrant
Qdrant makes it easy to implement hybrid search through its Query API. Here’s how you can make it happen in your own project:
**Example Hybrid Query:**
```python
client.query_points(
collection_name="{collection_name}",
prefetch=... | [
0.027109649032354355,
-0.04996480047702789,
-0.057247914373874664,
-0.042387597262859344,
0.0717640221118927,
-0.030199674889445305,
0.09111682325601578,
0.05334308370947838,
0.05603087693452835,
-0.023714927956461906,
0.02343941293656826,
0.02678965963423252,
0.07732756435871124,
-0.03807... |
d3f8fd12-1c0f-50d8-8bff-c5b2f9af2c95 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Configuring Memory Tiers > Limitations | documentation | false | Memory Tiers > Configuring Memory Tiers > Limitations
- Qdrant rejects `pinned` for dense vectors and payloads, since both only support a memory-mapped in-RAM representation (`cached` or `cold`).
- For sparse vectors, only the sparse vector index has a `memory` parameter. Qdrant doesn't offer a RAM cache for sparse ve... | [
0.03978247940540314,
-0.060060009360313416,
-0.019709134474396706,
-0.03955944627523422,
0.04420632869005203,
-0.034205496311187744,
0.08067996799945831,
0.026333119720220566,
0.10312473773956299,
-0.005918832495808601,
0.025253448635339737,
0.03967581316828728,
0.019036835059523582,
0.010... |
d3fac5e2-af93-5da5-9880-9f6976a2a41d | /documentation/upgrades/ | Upgrades | Docker Compose | documentation | false | Upgrades > Docker Compose
If you run Qdrant using Docker Compose, you can upgrade to a new version by updating the image version in your `docker-compose.yml` file and restarting the Qdrant service. | [
0.06366109848022461,
-0.03352390229701996,
-0.04412469267845154,
-0.046609122306108475,
0.05767961964011192,
-0.04437563195824623,
0.06502391397953033,
-0.009288011118769646,
0.04175279289484024,
-0.03955064341425896,
0.029191557317972183,
0.014815468341112137,
0.06053091958165169,
-0.0545... |
d402f486-cfc4-5c44-a979-d41d5d6356bb | /course/multi-vector-search/module-3/pooling-techniques/ | Pooling Techniques | Pooling for Multi-Vector Representations > Image-Specific Methods | course | false | Pooling Techniques > Pooling for Multi-Vector Representations > Image-Specific Methods
For visual document representations like ColPali, spatial relationships in the patch grid enable effective pooling strategies. As you learned in Module 2's visual interpretability lesson, patches in the same row or column often capt... | [
0.05296601727604866,
-0.019423019140958786,
-0.042380716651678085,
-0.02901337668299675,
0.09674999117851257,
-0.0189212579280138,
0.05111836642026901,
0.05056491494178772,
0.06254009902477264,
0.010257032699882984,
0.03294732794165611,
-0.03101046197116375,
0.05003456771373749,
-0.0095513... |
d416eefe-2556-5408-a48f-9d96ccde0860 | /articles/what-is-vector-quantization/ | What is Vector Quantization? | Rescoring, Oversampling, and Reranking > 1. Initial Quantized Search | article | false | What is Vector Quantization? > Rescoring, Oversampling, and Reranking > 1. Initial Quantized Search
When you perform a search, Qdrant retrieves the top candidates using the quantized vectors based on their similarity to the query vector, as determined by the quantized data. This step is fast because we're using the qu... | [
0.061228781938552856,
-0.07831961661577225,
-0.03996472805738449,
-0.040830615907907486,
0.053607210516929626,
0.013030150905251503,
0.07241560518741608,
0.010823670774698257,
0.09089604765176773,
-0.01551522221416235,
0.03972764313220978,
0.03842584416270256,
0.07008713483810425,
-0.01088... |
d4262cb8-a5b4-5a8a-8745-92c40a82f86f | /documentation/examples/rag-chatbot-red-hat-openshift-haystack/ | Private Chatbot for Interactive Learning | Implementation > Indexing pipeline > Chunking | documentation | true | Private Chatbot for Interactive Learning > Implementation > Indexing pipeline > Chunking
`HTMLToDocument` returns Haystack `Document` instances, which are the base class containing some data to be queried.
However, a single document might be too long to be processed by the embedding model, and it also carries way too ... | [
0.03682461753487587,
-0.04997642710804939,
-0.058647703379392624,
-0.023186147212982178,
0.052650801837444305,
-0.03447248041629791,
0.049842316657304764,
0.0165114663541317,
0.0659545436501503,
0.018931599333882332,
0.015629544854164124,
0.04163464903831482,
0.03781943395733833,
-0.060263... |
d427806e-2c0e-5dbf-8d49-3e10efb3a84e | /documentation/private-cloud/changelog/ | Changelog | 1.9.9 (2026-06-24) | documentation | false | Changelog > 1.9.9 (2026-06-24)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.36.0 |
| operator | 2.30.0 |
| qdrant-cluster-manager | v0.3.19 |
| qdrant-cluster-exporter | 1.8.0 |
Latest validated Qdrant version: 1.18.2
* Updated operator... | [
0.036766380071640015,
-0.019764645025134087,
-0.0604703426361084,
-0.03575211390852928,
0.050967369228601456,
-0.04616745933890343,
0.06024850159883499,
0.03713395074009895,
0.052538588643074036,
-0.04182754084467888,
0.032329827547073364,
0.043017640709877014,
0.06086895242333412,
-0.0689... |
d428d57a-100f-5056-9310-362ece501672 | /documentation/tutorials-operations/secure-and-expose-hybrid-cloud/ | Securing and Exposing a Hybrid Cloud Cluster | Next Steps | documentation | false | Securing and Exposing a Hybrid Cloud Cluster > Next Steps
This covers authentication and TLS for a single cluster reachable from outside your Kubernetes network. From here, two things are worth doing before this goes to production:
1. replace both self-signed certificates with ones from a trusted CA: the `mkcert` cer... | [
0.055924106389284134,
-0.05882643908262253,
-0.06619025766849518,
-0.04190792888402939,
0.04622288793325424,
-0.04510980844497681,
0.05460862070322037,
0.03690825030207634,
0.02253660187125206,
-0.023243652656674385,
0.013103208504617214,
0.00676976190879941,
0.048249468207359314,
-0.01555... |
d4336e88-9e6a-593b-a045-121b5468a647 | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Implementation | documentation | false | GraphRAG with Qdrant and Neo4j > Implementation
We'll walk through a complete pipeline that ingests data into Neo4j and Qdrant, retrieves relevant data, and generates responses using an LLM based on the retrieved graph context.
The main components of this pipeline include data ingestion (to Neo4j and Qdrant), retriev... | [
0.008388115093111992,
-0.048335880041122437,
-0.04551036283373833,
-0.04618700221180916,
0.06953660398721695,
-0.03823915123939514,
0.06773028522729874,
0.07479266077280045,
0.020641466602683067,
-0.015694525092840195,
0.0126317348331213,
0.04401330649852753,
0.03930141404271126,
-0.031299... |
d4494a7b-5f31-57a8-bd3f-6ec8359e99b6 | /articles/what-is-rag-in-ai/ | Understanding Retrieval-Augmented Generation (RAG) | RAG architecture > The Generator | article | false | Understanding Retrieval-Augmented Generation (RAG) > RAG architecture > The Generator
With the top relevant chunks retrieved, it's now the generator's job to produce a final answer by synthesizing and expressing that information in natural language.
The generator is a large language model trained on massive datasets ... | [
-0.016412433236837387,
-0.02747637778520584,
-0.07128280401229858,
-0.04398040100932121,
0.07113506644964218,
-0.01607595942914486,
0.056911829859018326,
0.01938440650701523,
0.039187293499708176,
-0.0644557997584343,
0.03274907171726227,
0.03647662699222565,
0.04265449568629265,
-0.056529... |
d47143f1-bc56-5f0f-a4f7-e9f2afb6758e | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Qdrant Adds > L2 and Unnormalized Dot | article | false | TurboQuant in Qdrant > What Qdrant Adds > L2 and Unnormalized Dot
Vanilla TurboQuant assumes all inputs live on the unit sphere; that is, cosine distance only. We extend the scoring mechanism and unlock L2 and unnormalized dot by *storing the original L2 norm*, normalizing the vectors, and then applying the L2 norm ba... | [
0.056348465383052826,
-0.03542371466755867,
-0.0547889769077301,
-0.02327764220535755,
0.05671149119734764,
0.01190907135605812,
0.06908395886421204,
-0.0005036430084146559,
0.0885787159204483,
-0.023468125611543655,
0.04829837381839752,
0.019138192757964134,
0.04140917956829071,
-0.010600... |
d47bba02-8543-5904-9f6a-c642d6104962 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Migrating > Legacy Settings > Payloads | documentation | false | Memory Tiers > Migrating > Legacy Settings > Payloads
The legacy parameter is `on_disk_payload`, set on the collection.
| `memory` | Legacy value |
|---|---|
| `cached` | `on_disk_payload: false` |
| `cold` | `on_disk_payload: true` | | [
0.012409107759594917,
-0.02416377142071724,
0.0008903387933969498,
-0.0389028936624527,
0.055197469890117645,
-0.02866285853087902,
0.010380697436630726,
0.052739374339580536,
0.04849711433053017,
-0.06423953920602798,
0.00446583004668355,
0.0117637412622571,
0.04098549857735634,
-0.006324... |
d491b11f-858d-5d65-923a-a82c0f7f53bb | /documentation/fastembed/fastembed-quickstart/ | Quickstart | documentation | true | Quickstart
## Install FastEmbed
```python
pip install fastembed
```
Just for demo purposes, you will use Lists and NumPy to work with sample data.
```python
from typing import List
import numpy as np
```
## Load default model
In this example, you will use the default text embedding model, `BAAI/bge-small-en-v1.5`... | [
0.03397087752819061,
-0.04913307726383209,
-0.021248990669846535,
-0.06605731695890427,
0.05255790054798126,
-0.04354038089513779,
0.062162578105926514,
0.06874535232782364,
0.04016578570008278,
-0.038194943219423294,
0.04669712856411934,
0.03391289338469505,
0.04667885601520538,
-0.048897... | |
d4a6f937-db1f-50bc-b5ca-5a5af780ae53 | /documentation/tutorials-build-essentials/data-ingestion-beginners/ | S3 Ingestion | Step 7: Search | documentation | true | S3 Ingestion > Step 7: Search
Search the review text with a natural-language query. Wrap the query in a `models.Document` with the same model used for ingestion, and choose the vector to search with `using`:
```python
results = client.query_points(
collection_name=COLLECTION,
query=models.Document(text="Phone... | [
0.031063416972756386,
-0.07249614596366882,
-0.05638478323817253,
-0.03244013711810112,
0.07581739872694016,
-0.014401549473404884,
0.05552295967936516,
0.042325906455516815,
0.0450197234749794,
0.0016583944670856,
-0.0029219212010502815,
0.041244614869356155,
0.049530576914548874,
-0.0434... |
d4b9df91-595c-5a1c-ad9d-13319faf90d5 | /documentation/embeddings/bedrock/ | Amazon Bedrock | Embed Images | documentation | true | Amazon Bedrock > Embed Images
Nova Multimodal Embeddings maps text, images, documents, video, and audio into one vector space, so a text query can find an image. Its vectors don't share a space with Titan's, so store them in a separate collection.
Set `embeddingPurpose` to `GENERIC_INDEX` when you index content of an... | [
0.03679672256112099,
-0.022424353286623955,
-0.0389874242246151,
-0.023422686383128166,
0.03398846834897995,
-0.037481896579265594,
0.0630461648106575,
0.049899421632289886,
0.023499660193920135,
-0.002110268222168088,
0.019993631169199944,
0.042509905993938446,
0.035481881350278854,
-0.02... |
d4c9d211-cb4a-5c1a-af03-8af567992820 | /course/essentials/day-4/rescoring-oversampling-indexing/ | Accuracy Recovery with Rescoring | Oversampling | course | false | Accuracy Recovery with Rescoring > Oversampling
Since some relevant matches could be missed in the initial search, to compensate for that we will apply oversampling. Which means that you will retrieve more candidates, increasing the chances that the most relevant vectors make it into the final results.
For example, i... | [
0.029107052832841873,
-0.09558805078268051,
-0.029700854793190956,
-0.05458228662610054,
0.05824102833867073,
0.003955019637942314,
0.054370176047086716,
0.006903028581291437,
0.08556599915027618,
-0.015819160267710686,
0.02595377527177334,
0.004326360300183296,
0.0788329690694809,
-0.0267... |
d4f7f4e5-cd51-590d-a363-c9a60dca3638 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantRelease | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantRelease
QdrantRelease describes an available Qdrant release
_Appears in:_
- [QdrantReleaseList](#qdrantreleaselist)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `kind` _string_ | `Qdrant... | [
0.013739785179495811,
-0.04832759127020836,
-0.042968034744262695,
-0.07030344754457474,
0.0828232690691948,
-0.039847929030656815,
0.0519385039806366,
0.05424187704920769,
0.04299532622098923,
-0.06742199510335922,
0.038422781974077225,
0.01796596124768257,
0.0780540406703949,
-0.00746127... |
d500656b-577a-594f-86e0-d7e1d9a82474 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Migrating > Legacy Settings > Sparse Vector Index | documentation | false | Memory Tiers > Migrating > Legacy Settings > Sparse Vector Index
The legacy parameter is `on_disk`.
| `memory` | Legacy value |
|---|---|
| `pinned` | `on_disk: false` |
| `cached` | No legacy equivalent |
| `cold` | `on_disk: true` | | [
0.030341709032654762,
-0.0578080452978611,
-0.00012782096746377647,
-0.029298411682248116,
0.05089123919606209,
-0.02153599262237549,
0.03925975039601326,
0.03761465847492218,
0.056355129927396774,
-0.04763556271791458,
0.00024829444009810686,
0.025766773149371147,
0.03247622027993202,
-0.... |
d5073bb3-bbb7-58bb-92ac-4ee1c2b87ad4 | /documentation/migration-guidance/search-quality/ | Search Quality | documentation | false | Search Quality
Two systems can hold identical vectors and produce different search results because of differences in indexing, quantization, scoring, and filtering implementation.
This is perhaps the hardest part of migration verification. The guide breaks it into **three tiers** so you can pick the level of rigor th... | [
0.030757835134863853,
-0.0724344328045845,
-0.07224182039499283,
-0.022599471732974052,
0.048770722001791,
0.025217154994606972,
0.03152342885732651,
0.044767946004867554,
0.08997499197721481,
-0.023830058053135872,
-0.0059323920868337154,
0.013597385957837105,
0.08037891983985901,
-0.0313... | |
d5133fdc-15b1-5ae4-91bd-ce5eee469f3b | /course/essentials/day-7/camel/ | Integrating with Camel AI | CAMEL Auto-Retrieval Architecture > Core Concept | course | false | Integrating with Camel AI > CAMEL Auto-Retrieval Architecture > Core Concept
Traditional agent systems require manual context management and retrieval setup. CAMEL's Auto-Retrieval approach automates this process by:
- **Expanding Agent Capability**: Using RAG techniques to provide additional context to agents, enabl... | [
0.014201898127794266,
-0.06178050860762596,
-0.04853077232837677,
-0.026809394359588623,
0.09127248823642731,
-0.03159152343869209,
0.05033034086227417,
0.011705460026860237,
0.036767225712537766,
-0.0012823204742744565,
0.05072300508618355,
-0.026421356946229935,
0.04282175004482269,
-0.0... |
d51371d2-739b-5711-8169-82a40ec6fad0 | /course/multi-vector-search/module-1/multi-vector-in-qdrant/ | Multi-Vector Embeddings in Qdrant | Indexing Multi-Vector Documents | course | true | Multi-Vector Embeddings in Qdrant > Indexing Multi-Vector Documents
With your collection configured, you can now index documents. Each document needs multiple token embeddings - one for each token in the text:
```python
import uuid
documents = [
# Document A: Highly relevant - addresses all query aspects
"Wh... | [
0.040044158697128296,
-0.04065534472465515,
-0.036955177783966064,
-0.049611084163188934,
0.06431923061609268,
-0.04047972708940506,
0.07448455691337585,
0.04558740556240082,
0.056651294231414795,
-0.033347468823194504,
0.027386482805013657,
0.03285445645451546,
0.033907610923051834,
-0.04... |
d51d39e3-5444-59ef-96d5-7953cb1ecd30 | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | Silent Settings Can Break Quality > Sparse Retrieval | documentation | false | What to Check Before Tuning a Qdrant Collection > Silent Settings Can Break Quality > Sparse Retrieval
These settings apply whether the collection has thousands of documents or billions.
**[Modifier.IDF](/documentation/manage-data/indexing/#idf-modifier)** Use this modifier for sparse vectors from BM25 or miniCOIL. B... | [
0.050732530653476715,
-0.02894405648112297,
-0.008021838963031769,
-0.046692319214344025,
0.04018339142203331,
-0.0444878488779068,
0.046049222350120544,
0.07063838839530945,
0.08134255558252335,
-0.060027461498975754,
0.030736275017261505,
0.012951086275279522,
0.033711615949869156,
-0.02... |
d5221b56-db08-5a0c-97b4-bfefb7beb5f5 | /documentation/search-tuning/when-a-reranker-is-worth-it/ | When Is a Reranker Worth It? | Compare with the Best First Stage | documentation | false | When Is a Reranker Worth It? > Compare with the Best First Stage
| Dataset | Best Model | vs. Default RRF | vs. Tuned Fusion | Held Out |
|---|---|---|---|---|
| SciFact | `jina-reranker-v2` @ 200 | +0.057 | +0.033 | no, 37% |
| ArguAna | `jina-reranker-v2` @ 25 | +0.031 | +0.017 | no, 2.5% |
| WANDS | `MiniLM-L-6` @ ... | [
0.036503683775663376,
-0.012313936837017536,
-0.07294961810112,
-0.028012216091156006,
0.048582591116428375,
-0.0325230173766613,
0.04835823178291321,
0.026968492195010185,
0.05996204912662506,
-0.04173761606216431,
0.03463977202773094,
-0.01651882939040661,
0.04285141080617905,
-0.0250866... |
d526173c-8d89-5f0d-aecd-3a2ae1aec195 | /documentation/search/search/ | Search | Grouping API > Search Groups | documentation | true | Search > Grouping API > Search Groups
REST API ([Schema](https://api.qdrant.tech/api-reference/search/query-points-groups)):
```python
client.query_points_groups(
collection_name="{collection_name}",
# Same as in the regular query_points() API
query=[1.1],
# Grouping parameters
group_by="document_... | [
0.020391186699271202,
-0.04215225577354431,
-0.03040838986635208,
-0.020586654543876648,
0.07365372031927109,
-0.031814094632864,
0.05586304888129234,
0.022214341908693314,
0.07011739164590836,
-0.03110768273472786,
0.04590979963541031,
0.02392580173909664,
0.015315733850002289,
-0.0281604... |
d5284ad5-4066-518b-ad91-b6d1196cce75 | /documentation/overview/ | Overview | Scaling Considerations | documentation | false | Overview > Scaling Considerations
The default configuration of Qdrant is sensible when you are starting to work on a POC or your side project. However, when transitioning to production and experiencing the growth of data size and concurrent users, your expectations regarding high availability, latency, or throughput w... | [
0.022315530106425285,
-0.04519769921898842,
-0.03305552154779434,
-0.030582081526517868,
0.04377071186900139,
-0.0891662985086441,
0.08521339297294617,
0.04781598225235939,
0.07990283519029617,
0.007587978150695562,
0.019351068884134293,
-0.02410792000591755,
0.048638008534908295,
-0.04441... |
d52d59d2-727f-503e-b724-a769412f6cc7 | /documentation/search/search-relevance/ | Search Relevance | Relevance Feedback | documentation | true | Search Relevance > Relevance Feedback
The feedback model considers the second result with ID 222 to be the most relevant, which is a discrepancy with the retriever's ranking. Hence, this feedback can potentially help make the next iteration of retrieval better.
---
To leverage the feedback in search across the entir... | [
0.042738769203424454,
-0.04568491876125336,
-0.03181517496705055,
-0.039024218916893005,
0.04892841354012489,
-0.025052648037672043,
0.06348524242639542,
0.05301764979958534,
0.07304946333169937,
0.0038381500635296106,
0.006107733119279146,
0.01931474544107914,
0.061173807829618454,
-0.011... |
d5400ab9-9a8d-536d-8392-a77a3b508ba4 | /documentation/search/filtering/ | Filtering | Filtering Conditions > Text Match > Phrase Match | documentation | true | Filtering > Filtering Conditions > Text Match > Phrase Match
*Available as of v1.15.0*
A match `phrase` condition matches phrases. For example, the text `"quick brown fox"` matches the query `"brown fox"`, but not `"fox brown"`.
```python
models.FieldCondition(
key="description",
match=models.MatchPhrase(phr... | [
0.044092096388339996,
-0.05662938952445984,
-0.033460166305303574,
-0.04983774945139885,
0.05685880035161972,
-0.040809981524944305,
0.048688534647226334,
0.014135553501546383,
0.041777122765779495,
-0.029345376417040825,
0.035569313913583755,
0.02160857990384102,
0.054560668766498566,
-0.... |
d569e421-adc4-5a3b-a6cc-1d2abb0f9787 | /documentation/production-operations/memory-tiers/ | Memory Tiers in Qdrant: What to Use and When | When To Cache Everything | documentation | false | Memory Tiers in Qdrant: What to Use and When > When To Cache Everything
Don't cache a compressed copy alongside full-precision vectors unless RAM has room for both. It doubles the resident working set instead of shrinking it, since Qdrant's default is to pin that compressed copy rather than cache it.
Caching the full... | [
0.0449649952352047,
-0.03193376585841179,
-0.05443524569272995,
-0.03154275193810463,
0.06524652242660522,
-0.046834152191877365,
0.055828433483839035,
0.01774049736559391,
0.09178096801042557,
-0.011277248151600361,
-0.009197041392326355,
0.02731776051223278,
0.012687793001532555,
-0.0347... |
d5856337-1191-51f0-b2b3-5c94af552e87 | /documentation/cloud/encryption/ | Encryption at Rest | documentation | false | Encryption at Rest
Qdrant Managed Cloud encrypts all storage volumes at rest by default. [Premium customers](/documentation/cloud-premium/) can also use their own cloud key management service (KMS) key for additional control over their encryption. Enabling this requires opening a support ticket. Qdrant Support provide... | [
0.06150902435183525,
-0.020011847838759422,
-0.020388074219226837,
-0.05775223299860954,
0.0015723250107839704,
-0.04546816274523735,
0.05425348877906799,
0.03939170017838478,
0.08441472798585892,
-0.0008117733523249626,
0.002941048238426447,
-0.027077630162239075,
0.07352331280708313,
-0.... | |
d5867d5d-4dee-5204-8566-16f8fcadb3a5 | /articles/metric-learning-tips/ | Metric Learning Tips & Tricks | Neural rules | article | false | Metric Learning Tips & Tricks > Neural rules
Machine learning models rarely train to 100% accuracy.
In a conventional classifier, errors can only be eliminated by modifying and repeating the training process.
Metric training, however, is more flexible in this matter and allows you to introduce additional steps that a... | [
0.03637892007827759,
-0.022862857207655907,
-0.04441092535853386,
-0.00017697129806037992,
0.045517448335886,
-0.015050400048494339,
0.02908930554986,
0.060650184750556946,
0.08103121072053909,
-0.025473030284047127,
0.02220972627401352,
0.01855374127626419,
0.08490180969238281,
-0.0366106... |
d58b7f48-8f9e-5132-8f5e-f8ab6d01cf8d | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Search > What does the time field in the Query API response represent? Does it include network latency? | documentation | false | Qdrant Fundamentals > Search > What does the time field in the Query API response represent? Does it include network latency?
The time value is in seconds and represents the total duration the Qdrant server spent processing the request. It does not include network round-trip time between the client and the server. | [
-0.019439516589045525,
-0.03497137129306793,
-0.020316841080784798,
-0.05263542756438255,
0.04320792481303215,
-0.03269384801387787,
0.0502052940428257,
0.05559946596622467,
0.07174766808748245,
-0.034567493945360184,
0.05440574511885643,
-0.02769605442881584,
0.0764942318201065,
0.0040469... |
d5b5adf6-348f-52ca-90fd-2fccc55f24af | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > StoragePerformanceConfig | documentation | false | API Reference > qdrant.io/v1 > Resource Types > StoragePerformanceConfig
_Appears in:_
- [StorageConfig](#storageconfig)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `optimizer_cpu_budget` _integer_ | OptimizerCPUBudget defines the number of CPU allocation.If 0 - auto selection, keep 1 o... | [
0.017875762656331062,
-0.04166749119758606,
-0.040666982531547546,
-0.03885028511285782,
0.07600880414247513,
-0.020596079528331757,
0.02505870722234249,
0.055890608578920364,
0.0731138065457344,
-0.04733872786164284,
0.013833542354404926,
0.0025744796730577946,
0.035738255828619,
-0.04657... |
d5d9901c-8849-585d-a61d-827ff982a6d8 | /documentation/embeddings/qdrant-cloud-inference/ | Qdrant Cloud Inference | Embed Documents and Queries | documentation | true | Qdrant Cloud Inference > Embed Documents and Queries
Where a vector would go, pass a `Document` with the text and the model name, both when you upsert points and when you query. Replace `<the-model-to-use>` with a model from the Models tables:
```python
from qdrant_client import QdrantClient
from qdrant_client.models... | [
0.05487406998872757,
-0.06987908482551575,
-0.01928640343248844,
-0.040939148515462875,
0.06094234064221382,
-0.03372001275420189,
0.08565893024206161,
0.021152319386601448,
0.02283266745507717,
0.008465705439448357,
0.012640397064387798,
0.018864048644900322,
0.031357984989881516,
-0.0234... |
d5f7a00b-c11a-56ad-bd8c-c706bce3d42d | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Hybrid search: combining sparse and dense vectors > Mixing or fusion | article | false | Understanding SPLADE and Sparse Vectors > Hybrid search: combining sparse and dense vectors > Mixing or fusion
Fusion mixes the results from both dense and sparse vectors based purely on their ranks or relative scores. This is a simple and effective approach, but it doesn't take into account the semantic similarity be... | [
0.07126078754663467,
-0.04404113441705704,
-0.06125568971037865,
-0.05160844326019287,
0.048588257282972336,
-0.01837296038866043,
0.08713500946760178,
0.02611856907606125,
0.07463817298412323,
-0.03298161178827286,
0.03273855149745941,
0.014016752131283283,
0.04247812554240227,
0.01825023... |
d64063da-854d-5579-9ba8-59b8d38517df | /documentation/tutorials-search-engineering/turbo4-multivector-search/ | Compressed Multivector Search | documentation | false | Compressed Multivector Search
`turbo4` is inspired by [Google's TurboQuant](https://research.google/blog/turboquant-redefining-ai-efficiency-with-extreme-compression/) quantization technique: each vector is mathematically rotated so its information spreads evenly across all dimensions, which keeps the loss during comp... | [
0.03776500001549721,
-0.03324548900127411,
-0.057555440813302994,
-0.03326820954680443,
0.057429660111665726,
-0.009457353502511978,
0.0670974850654602,
0.022539570927619934,
0.06443098932504654,
-0.019108159467577934,
0.0513017512857914,
0.038189563900232315,
0.03530558943748474,
-0.02899... | |
d642126f-0998-53b4-94ed-075541c3b884 | /documentation/production-operations/memory-tiers/ | Memory Tiers in Qdrant: What to Use and When | How Qdrant's Memory Tiers Work | documentation | false | Memory Tiers in Qdrant: What to Use and When > How Qdrant's Memory Tiers Work
RAM is fast and expensive, disk is slow and cheap, and a growing collection outgrows its RAM budget long before it outgrows its disk budget. Qdrant gives you three tiers to manage that trade-off:
- **Pinned.** Lives on the heap and never ge... | [
0.02780725434422493,
-0.049882903695106506,
-0.05049816519021988,
-0.030072953552007675,
0.05837224796414375,
-0.011863622814416885,
0.045469678938388824,
0.013646349310874939,
0.12300629913806915,
-0.015222199261188507,
-0.0021084919571876526,
0.015187067911028862,
0.0374632328748703,
-0.... |
d64a70cd-6bba-59a9-b68a-1bf3ea7a7be3 | /documentation/security/ | Security | Audit Logging > Query Audit Logs | documentation | false | Security > Audit Logging > Query Audit Logs
| Field | Type | Description |
|---|---|---|
| `timestamp` | ISO-8601 | When the access check occurred. |
| `method` | string | API method name, for example `upsert_points`, `search_points`. |
| `auth_type` | `"Jwt"` \| `"ApiKey"` \| `"None"` | How the request was authentica... | [
0.021970847621560097,
-0.03434842824935913,
-0.037271127104759216,
-0.02507687360048294,
0.030723905190825462,
-0.017003806307911873,
0.0334063358604908,
0.08118195086717606,
0.08636461198329926,
-0.05899347364902496,
0.04502183571457863,
0.04844965413212776,
0.03887906298041344,
-0.018631... |
d65134e2-6d4a-586a-ac18-4c29fd989121 | /documentation/cloud/cluster-monitoring/ | Monitor Clusters | Grafana Dashboard > Cluster System Metrics /sys_metrics | documentation | false | Monitor Clusters > Grafana Dashboard > Cluster System Metrics /sys_metrics
| Name | Type | Meaning |
|-----------------------------------... | [
0.007254278752952814,
-0.013384820893406868,
-0.041248977184295654,
0.014374817721545696,
0.05761206895112991,
-0.059430744498968124,
0.06712563335895538,
0.07843843102455139,
0.05943701043725014,
-0.055484045296907425,
0.029183240607380867,
-0.00890683475881815,
0.045374732464551926,
0.00... |
d652b8ec-2037-59b0-ae62-37b371db049d | /documentation/edge/edge-synchronization-guide/ | Synchronize with a Server | documentation | false | Synchronize with a Server
Qdrant Edge can be synchronized with a collection from an external Qdrant server to support use cases like:
- **Offload indexing**: Indexing is a computationally expensive operation. By synchronizing an Edge Shard with a server collection, you can offload the indexing process to a more power... | [
0.026698032394051552,
-0.02161296084523201,
-0.06306988000869751,
-0.028662778437137604,
0.08021702617406845,
-0.024221953004598618,
0.06508947163820267,
0.011136455461382866,
0.09339989721775055,
-0.02032904513180256,
0.035809267312288284,
0.018276607617735863,
0.03646069020032883,
-0.000... | |
d691ac77-517c-5432-98c8-73ea1f4aa717 | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Blue-Green Migration > Step 2: Enable Dual Writes | documentation | false | Migrate to a New Embedding Model > Blue-Green Migration > Step 2: Enable Dual Writes
- `.delete` - removing specified points from the collection
- `.update_vectors` - updating specified vectors on points
- `.delete_vectors` - deleting specified vectors from points
- `.set_payload` - setting payload values for specifie... | [
0.022179434075951576,
-0.045823775231838226,
-0.03972778469324112,
-0.004625263623893261,
0.04223470389842987,
-0.0025203325785696507,
0.01943904720246792,
0.038482435047626495,
0.05450725555419922,
-0.037807174026966095,
0.025958703830838203,
0.011516102589666843,
0.023253971710801125,
-0... |
d696088e-b62b-57f7-a6f0-eb7320f36d94 | /course/beginners/module-6/search-from-examples/ | Searching From Examples and Feedback | course | false | Searching From Examples and Feedback
Module 6
Some searches have no query text. A reader clicks "more like this", or an analyst has three documents that are right and two that are wrong and no words for what separates them.
The [Recommendation API](/documentation/search/explore/#recommendation-api) searches from pos... | [
0.010243235155940056,
-0.03948744013905525,
-0.03106333129107952,
-0.025955576449632645,
0.05496760457754135,
-0.01364562101662159,
0.05173517018556595,
0.07143993675708771,
0.046183641999959946,
-0.035191379487514496,
-0.0056574372574687,
0.0637785941362381,
0.04694489762187004,
-0.033083... | |
d6a14e6b-24b1-59e1-8fde-3cceb88b033d | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search | article | false | Why Vector Search Needs a Dedicated Database > Vector Search
Unlike traditional databases that serve as data stores, **vector databases are more like search engines**. They are designed to be **scalable**, always **available**, and capable of delivering high-speed search results even under heavy loads. Just as Google ... | [
-0.0488714799284935,
-0.04342695698142052,
-0.05981891229748726,
-0.03823811933398247,
0.025441523641347885,
-0.02999952621757984,
0.052721425890922546,
0.00968272052705288,
0.06768008321523666,
-0.009089314378798008,
0.033310580998659134,
0.05008033663034439,
0.06182808056473732,
-0.00487... |
d6aac677-2239-5779-8874-98212b5587b8 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > ClusterPhase | documentation | false | API Reference > qdrant.io/v1 > Resource Types > ClusterPhase
_Underlying type:_ _string_
_Appears in:_
- [QdrantClusterStatus](#qdrantclusterstatus)
| Field | Description |
| --- | --- |
| `Creating` | |
| `FailedToCreate` | |
| `Updating` | |
| `FailedToUpdate` | |
| `Scaling` | |
| `Upgrading` | |
| `Suspend... | [
0.04993583261966705,
-0.02413923107087612,
-0.026417864486575127,
-0.05577899143099785,
0.08966333419084549,
-0.031675636768341064,
0.03572946414351463,
0.04562200605869293,
0.06623809039592743,
-0.04873239994049072,
0.06671963632106781,
0.015227477997541428,
0.04940546676516533,
-0.019095... |
d6b597be-6864-55c8-b092-e3c5f6b4d72f | /documentation/data-management/airbyte/ | Airbyte | Setting up connection | documentation | false | Airbyte > Setting up connection
Airbyte combines sources and destinations into a single entity called a connection. Once you have a destination
configured and a source, you can create a connection between them. It doesn't matter what source you use, as
long as Airbyte supports it. The process is pretty straightforward... | [
-0.015539783053100109,
-0.05358695983886719,
-0.06749890744686127,
-0.04866473749279976,
0.055683135986328125,
-0.004381811711937189,
0.01854681968688965,
0.04394339770078659,
0.017431490123271942,
-0.021320998668670654,
0.021736755967140198,
-0.029092393815517426,
0.03561420366168022,
0.0... |
d6bc5aee-d32a-5f21-99d0-4dc895014759 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-4/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization | Cross-Domain Evaluation | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization > Cross-Domain Evaluation
We took our Amazon ESCI-trained model and tested it on three additional datasets:
- **WANDS** (Wayfair): Furniture and home goods search
- **Home Depot**: Hardware and home improvement search
- **M... | [
0.05159243941307068,
-0.008958342485129833,
-0.06866633147001266,
-0.022191757336258888,
0.028699342161417007,
-0.049813203513622284,
0.055894821882247925,
0.009559853002429008,
0.06959753483533859,
-0.026016999036073685,
0.03252531215548515,
0.02795029804110527,
0.062157388776540756,
-0.0... |
d6c37e47-831b-5c98-85d8-38a0e5fae0d9 | /documentation/migration-guidance/pre-migration-baseline/ | Pre-Migration Baseline | What to Capture > 4. System Configuration Snapshot | documentation | true | Pre-Migration Baseline > What to Capture > 4. System Configuration Snapshot
Record the configuration of your source system that affects search behavior:
```
- Software version (e.g., Pinecone API version, Weaviate 1.24, Milvus 2.3)
- Index/collection creation parameters
- Quantization settings (PQ, SQ, none)
- HNSW p... | [
0.038985475897789,
-0.08224210888147354,
-0.023107048124074936,
-0.06093175336718559,
0.021214816719293594,
0.010302218608558178,
0.06870612502098083,
0.05099131539463997,
0.09270510077476501,
-0.03016607277095318,
0.0006950016249902546,
-0.0005491582560352981,
0.04389316961169243,
-0.0251... |
d6ee6014-c252-576a-8833-643bd3db58ed | /documentation/fastembed/fastembed-splade/ | Working with SPLADE | Analyze results | documentation | true | Working with SPLADE > Analyze results
Let's use the tokenizer vocab to make sense of these indices.
```python
import json
from tokenizers import Tokenizer
tokenizer = Tokenizer.from_pretrained("Qdrant/Splade_PP_en_v1")
```
The `get_tokens_and_weights` function takes a `SparseEmbedding` object and a `tokenizer` as i... | [
0.025220563635230064,
-0.02942086011171341,
-0.019512128084897995,
-0.07872458547353745,
0.05578847974538803,
-0.0299279373139143,
0.03711874783039093,
0.052515435963869095,
0.0656963661313057,
-0.0104117626324296,
0.029693981632590294,
0.04780680313706398,
0.004625444300472736,
0.00093329... |
d709f3be-5ce3-5cdf-b940-84b06ff1718f | /documentation/search/text-search/ | Text Search | Filtering Versus Querying | documentation | false | Text Search > Filtering Versus Querying
When it comes to lexical search in Qdrant, it's important to distinguish between filtering and querying. Filtering is used to narrow down results based on exact matches or specific criteria, while querying involves finding relevant documents based on the content of the text. In ... | [
0.024178531020879745,
-0.037542086094617844,
-0.054895009845495224,
-0.025107668712735176,
0.04022561013698578,
-0.03507184609770775,
0.059949833899736404,
0.046494558453559875,
0.09646513313055038,
-0.00045128754572942853,
0.03095451556146145,
0.040399789810180664,
0.06204168125987053,
-0... |
d70be7c8-f85f-53c0-8674-debd19ea709f | /documentation/embeddings/bedrock/ | Amazon Bedrock | documentation | false | Amazon Bedrock
[Amazon Bedrock](https://aws.amazon.com/bedrock/) serves embedding models from Amazon, Cohere, and TwelveLabs through the AWS SDKs, inside your AWS account. Call Bedrock from your application and send the vectors to Qdrant. | [
0.029114941135048866,
-0.002793569816276431,
-0.018234536051750183,
-0.023572074249386787,
0.012218020856380463,
-0.04115201532840729,
0.06347686797380447,
0.04442967474460602,
0.010031343437731266,
-0.006452005356550217,
0.0480627566576004,
0.021709753200411797,
0.051458753645420074,
-0.0... | |
d70fe3ae-9b6a-5e0c-acd8-5c3f4f0655be | /documentation/data-management/spark/ | Apache Spark | Usage | documentation | true | Apache Spark > Usage
### Creating a Spark session with Qdrant support
```python
from pyspark.sql import SparkSession
spark = SparkSession.builder.config(
"spark.jars",
"path/to/file/spark-VERSION.jar", # Specify the path to the downloaded JAR file
)
.master("local[*]")
.appName("qdrant")... | [
0.05839473754167557,
-0.04985305294394493,
-0.026382382959127426,
-0.0410965159535408,
0.05627485737204552,
-0.08386990427970886,
0.07243599742650986,
0.06745339184999466,
0.03005741536617279,
-0.06595540046691895,
0.025463595986366272,
0.057843729853630066,
0.013612703420221806,
-0.016488... |
d712780e-be59-5f98-819f-dc3f91e7e9e8 | /course/essentials/day-0/building-simple-vector-search/ | Implementing a Basic Vector Search | Step 2: Import Required Libraries | course | true | Implementing a Basic Vector Search > Step 2: Import Required Libraries
Import the necessary modules from the qdrant-client package. The QdrantClient class establishes connection to Qdrant, while the models module provides configurations for `Distance`, `VectorParams`, and `PointStruct`.
```python
from qdrant_client i... | [
0.011606525629758835,
-0.0649002194404602,
-0.03918476402759552,
-0.0017665133345872164,
0.05299481004476547,
-0.05523309111595154,
0.09597203135490417,
0.0645570158958435,
0.0900818258523941,
-0.00291591789573431,
0.02329275570809841,
0.006653949152678251,
0.019016120582818985,
-0.0468132... |
d719e7d6-97bd-5b7e-a803-3e85d358fab8 | /documentation/manage-data/collections/ | Collections | Update Collection > Update Collection Parameters | documentation | true | Collections > Update Collection > Update Collection Parameters
Dynamic parameter updates may be helpful, for example, for more efficient initial loading of vectors.
For example, you can disable indexing during the upload process, and enable it immediately after the upload is finished.
As a result, you will not waste e... | [
0.013339899480342865,
-0.057360608130693436,
-0.061006832867860794,
-0.019341619685292244,
0.051968738436698914,
-0.025971446186304092,
0.025609774515032768,
0.044274043291807175,
0.08966682851314545,
-0.04950786381959915,
0.013004090636968613,
0.04058527201414108,
0.023549329489469528,
-0... |
d728e238-5ec9-54b3-997e-30853cb988cb | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Disable Updating via Non Indexed Payload | documentation | true | Administration > Strict Mode > Disable Updating via Non Indexed Payload
Setting `unindexed_filtering_update` to false prevents updating points by filtering on a non indexed payload key which can be very slow.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
... | [
0.04737833887338638,
-0.005711435340344906,
-0.039684996008872986,
-0.0097140371799469,
0.06154265254735947,
0.007122204639017582,
0.004546887706965208,
0.017907164990901947,
0.0645822286605835,
-0.023204684257507324,
0.020575322210788727,
0.04728890210390091,
0.051195964217185974,
-0.0110... |
d72a2d17-722f-5711-8f4e-2ae9eae89a75 | /documentation/ops-monitoring/monitoring/ | Monitoring & Telemetry | Metrics > Node Metrics /metrics | documentation | false | Monitoring & Telemetry > Metrics > Node Metrics /metrics
| Name | Type | Meaning |
| ----------------------------------- | ------- | ----------------------------------... | [
0.008993749506771564,
-0.02812039665877819,
-0.06574956327676773,
-0.009003931656479836,
0.0713634341955185,
-0.040985818952322006,
0.04324498400092125,
0.0899231880903244,
0.07209975272417068,
-0.04484786465764046,
0.002742299111559987,
-0.009023613296449184,
0.022600356489419937,
-0.0369... |
d75178cf-3b1b-50da-a4e6-fb8ad474de07 | /documentation/embeddings/mistral/ | Mistral | Next Steps | documentation | false | Mistral > Next Steps
- Read Mistral's [code embeddings guide](https://docs.mistral.ai/studio/knowledge-rag/embeddings/code_embeddings) for the `codestral-embed` output types.
- [Filter search results](/documentation/search/filtering/) by payload fields.
- [Combine Mistral vectors with sparse vectors](/documentation/se... | [
0.07513060420751572,
-0.046040117740631104,
-0.035923175513744354,
0.010587485507130623,
0.062415070831775665,
-0.02597961761057377,
0.07938627153635025,
0.017193373292684555,
0.041259218007326126,
-0.026607492938637733,
0.03713146597146988,
-0.006983906961977482,
0.0706804022192955,
-0.00... |
d764e901-5276-5feb-92b5-b4277f07d934 | /documentation/search/filtering/ | Filtering | Filtering Conditions > Exact Match Conditions > Match | documentation | true | Filtering > Filtering Conditions > Exact Match Conditions > Match
```python
models.FieldCondition(
key="color",
match=models.MatchValue(value="red"),
)
```
For the other types, the match condition will look exactly the same, except for the type used:
```python
models.FieldCondition(
key="count",
matc... | [
0.021579381078481674,
-0.052817292511463165,
-0.07943839579820633,
-0.025455346331000328,
0.04073745384812355,
-0.022923791781067848,
0.029765896499156952,
0.0247303806245327,
0.1004081666469574,
-0.009292376227676868,
0.012139057740569115,
0.039270199835300446,
0.059940557926893234,
-0.00... |
d767b30c-63e7-5437-b50f-1251f4f2b649 | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | Token Structure and Embeddings | course | false | How ColPali Models Work > Token Structure and Embeddings
Now that you understand ColPali's VLM foundation - SigLIP processing patches, Gemma-2B contextualizing features, and the projection layer generating embeddings - let's see how this architecture processes images into the final multi-vector representation.
When C... | [
0.033009693026542664,
-0.017692843452095985,
-0.04655400291085243,
-0.050462182611227036,
0.07847997546195984,
-0.03655100241303444,
0.059124186635017395,
0.07220596075057983,
0.05255448818206787,
-0.03951867297291756,
0.038181353360414505,
0.001438451581634581,
0.031070999801158905,
-0.04... |
d78636e8-5cf3-5c8f-9161-b3e6f6d93435 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantConfiguration | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantConfiguration
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `collection` _[QdrantConfigurationCollection](#qdrantconfigurationcollection)_ | Collection specifies the default colle... | [
0.04077602177858353,
-0.04485836625099182,
-0.03351952135562897,
-0.05271541327238083,
0.05312597379088402,
-0.06112876906991005,
0.05917467176914215,
0.07530637085437775,
0.04749401658773422,
-0.029925275593996048,
0.003151858691126108,
0.0005133333615958691,
0.04084533825516701,
-0.02766... |
d787da69-3ffd-5e9b-a8da-ef3522da8d4f | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > ClusterManagerReponse | documentation | false | API Reference > qdrant.io/v1 > Resource Types > ClusterManagerReponse
_Appears in:_
- [QdrantClusterStatus](#qdrantclusterstatus)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `description` _string_ | Description contains additional information about the last response | | Optional: \{\} ... | [
0.05092434585094452,
-0.028685500845313072,
-0.013810692355036736,
-0.07801316678524017,
0.07150706648826599,
-0.03894471004605293,
0.05233179032802582,
0.045662447810173035,
0.0787343829870224,
-0.05731960013508797,
0.06297045201063156,
0.02067226730287075,
0.05612735450267792,
-0.0008868... |
d79178c3-bfbe-5d3f-b855-1a988902fdab | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Number of Conditions in a Filter | documentation | true | Administration > Strict Mode > Maximum Number of Conditions in a Filter
A large number of filtering conditions are expensive to evaluate.
Setting `filter_max_conditions` caps the maximum number of conditions filters can have.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http:/... | [
-0.0049372101202607155,
-0.0403425432741642,
-0.051104385405778885,
-0.017086567357182503,
0.04504784196615219,
-0.01688968762755394,
0.037394315004348755,
0.06190295144915581,
0.06646750867366791,
-0.0152051392942667,
0.013800178654491901,
0.03524540364742279,
0.09819710999727249,
-0.0656... |
d7bb6eb8-5ce2-50a4-b183-ca5d44e9fc61 | /documentation/ops-monitoring/monitoring/ | Monitoring & Telemetry | Telemetry Endpoint | documentation | false | Monitoring & Telemetry > Telemetry Endpoint
Qdrant also provides a `/telemetry` endpoint, which provides information about the current state of the database, including the number of vectors, shards, and other useful information. You can find the full documentation for this endpoint in the [API reference](https://api.q... | [
0.011311067268252373,
-0.04157387837767601,
-0.025652846321463585,
-0.06938467919826508,
-0.00602064561098814,
-0.019262662157416344,
0.08852564543485641,
0.06107372045516968,
0.08037674427032471,
-0.04833730310201645,
0.04635677486658096,
0.010741831734776497,
0.060207244008779526,
-0.030... |
d7d1cfac-0da7-527b-8306-a2f73080c754 | /documentation/embeddings/ollama/ | Ollama | Setup | documentation | true | Ollama > Setup
[Install Ollama](https://ollama.com/download) and pull the model:
```bash
ollama pull qwen3-embedding:0.6b
```
Install the Ollama SDK and the Qdrant client:
- Python: `pip install ollama qdrant-client`
- TypeScript: `npm install ollama @qdrant/js-client-rest`
Create both clients and a collection siz... | [
0.03841201588511467,
-0.04992175102233887,
-0.023743681609630585,
-0.028194328770041466,
0.07552510499954224,
-0.061671409755945206,
0.08631087094545364,
0.03155852481722832,
0.05304459109902382,
0.006953679956495762,
0.019878674298524857,
0.001975478371605277,
0.024358494207262993,
-0.044... |
d7d4ef49-774a-585d-83e9-c311ec399f4c | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | Silent Settings Can Break Quality > Dense Search and Indexing | documentation | false | What to Check Before Tuning a Qdrant Collection > Silent Settings Can Break Quality > Dense Search and Indexing
**[Vectors are indexed](/documentation/manage-data/collections/#collection-info)** Call `GET /collections/{collection_name}` and compare `indexed_vectors_count` with `points_count`. Both are approximate, and... | [
0.05170033872127533,
-0.05096622183918953,
-0.051990754902362823,
-0.017440181225538254,
0.020310664549469948,
-0.027762647718191147,
0.055304016917943954,
0.04552866145968437,
0.08147655427455902,
-0.04161391407251358,
0.01179337315261364,
0.05124901607632637,
0.024876415729522705,
-0.012... |
d7d5200a-1baf-5d2b-b395-906f02fe19e3 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Adding Relevance Feedback Query to a Search Pipeline > 1. Vanilla Initial Retrieval | documentation | true | Relevance Feedback Retrieval in Qdrant > Adding Relevance Feedback Query to a Search Pipeline > 1. Vanilla Initial Retrieval
We run simple semantic similarity search with our retriever, as we'd normally do in our search application.
```python
query_embedding = retriever.embed_query(query)
CONTEXT_LIMIT = 3
responses... | [
0.06012411788105965,
-0.0678679421544075,
-0.05227312073111534,
-0.053096018731594086,
0.07001161575317383,
-0.016756361350417137,
0.04509882256388664,
0.019545435905456543,
0.023500066250562668,
-0.021123463287949562,
0.023405559360980988,
0.05355397239327431,
0.07630251348018646,
-0.0012... |
d7e32067-2d07-5ab1-837e-8fe20972d86d | /documentation/tutorials-build-essentials/semantic-cache/ | Semantic Caching for RAG | Conclusion | documentation | false | Semantic Caching for RAG > Conclusion
We put a semantic cache in front of a RAG pipeline: a Qdrant collection of past questions and their answers, looked up before every RAG call.
The key takeaways:
- **The threshold decides what the cache serves.** It depends on your embedding model and your questions, so calibrate... | [
0.0341934971511364,
-0.029444681480526924,
-0.038962509483098984,
-0.05141649395227432,
0.02825230546295643,
-0.017815781757235527,
0.054144810885190964,
0.01539805717766285,
0.04445011913776398,
-0.06123900040984154,
-0.005742426961660385,
0.024012120440602303,
0.07249942421913147,
-0.012... |
d7f96f01-a8ad-57a4-8c53-0a02c51812bc | /course/ | Qdrant Academy | Upcoming Courses > Intermediate Level | course | false | Qdrant Academy > Upcoming Courses > Intermediate Level
Intermediate courses are recommended for those that have completed the Beginner Level Modules first, and extend knowledge into more practical usage of Qdrant in the real-world.
- title: "Optimizing Performance"
content: |
- Fine-tuning HNSW parameters
-... | [
0.00445145508274436,
-0.030093634501099586,
-0.03242627531290054,
-0.025008447468280792,
0.05617375671863556,
-0.03701822832226753,
0.036779437214136124,
0.08382013440132141,
0.07321426272392273,
-0.02898288145661354,
0.047761011868715286,
0.029732728376984596,
0.015487665310502052,
-0.052... |
d800cfea-2d41-540b-8e7a-a8b11f8d941a | /documentation/examples/hybrid-search-llamaindex-jinaai/ | Chat With Product PDF Manuals Using Hybrid Search | Configure Hybrid Retrieval and the Prompt | documentation | true | Chat With Product PDF Manuals Using Hybrid Search > Configure Hybrid Retrieval and the Prompt
- `similarity_top_k=12` requests up to 12 dense candidates.
- `sparse_top_k=12` requests up to 12 sparse candidates.
- `hybrid_top_k=2` requests up to 2 results after fusion; omitting it falls back to `similarity_top_k`.
Can... | [
0.03486387059092522,
-0.06738582998514175,
-0.05707864835858345,
-0.0513547845184803,
0.07387962192296982,
-0.026369605213403702,
0.06365745514631271,
0.044048357754945755,
0.09306086599826813,
-0.029623057693243027,
0.0392400361597538,
0.017165929079055786,
0.050819069147109985,
-0.007007... |
d800fa11-f218-590c-bc80-844b4c04e365 | /documentation/edge/edge-api/shard-lifecycle/ | Shard Lifecycle | Get Shard Information | documentation | true | Shard Lifecycle > Get Shard Information
Returns metadata about the shard's contents.
```python
def info(self) -> ShardInfo
```
`ShardInfo` carries the following fields. The counts are summed across segments, and a point can be present in more than one segment before it is optimized, so `points_count` and `indexed_ve... | [
0.002795896725729108,
0.0022311899811029434,
-0.046242084354162216,
-0.029711168259382248,
0.059436846524477005,
-0.04521127790212631,
0.05477425828576088,
0.06114397943019867,
0.050256919115781784,
-0.04438372328877449,
0.05938463285565376,
0.019797148182988167,
-0.009144915267825127,
-0.... |
d81144d0-4c68-5552-94e9-70ce6b770b7f | /course/beginners/module-2/ | Module 2: First Principles of Vector Search | course | false | Module 2: First Principles of Vector Search
Module 2
Start with the [Module Overview](/course/beginners/module-2/module-overview/), then work through the path.
## Today's Path
1. [From Idea to System](/course/beginners/module-2/from-idea-to-system/)
2. [Core Data Model](/course/beginners/module-2/core-data-model/)
... | [
0.049477409571409225,
-0.05718105658888817,
-0.03473444655537605,
0.008180716075003147,
0.07301351428031921,
-0.0413481704890728,
0.03745405375957489,
0.0483647957444191,
0.07602710276842117,
-0.001047193305566907,
0.02396095171570778,
0.031044989824295044,
0.03937011957168579,
-0.02335466... | |
d820c8fc-c5c7-5e4d-bc62-6682d383cfc4 | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Introduction to GraphRAG | documentation | false | GraphRAG with Qdrant and Neo4j > Introduction to GraphRAG
Unlike RAG, which typically relies on document retrieval, GraphRAG builds knowledge graphs (KGs) to capture entities and their relationships. For datasets or use cases that demand human-level intelligence from an AI system, GraphRAG offers a promising solution:... | [
0.004064076580107212,
-0.03641575947403908,
-0.07864314317703247,
-0.0337420329451561,
0.07434133440256119,
-0.0176007691770792,
0.05478013679385185,
0.0589897520840168,
0.03587904945015907,
-0.03044288046658039,
0.011717556044459343,
0.015131250955164433,
0.06955563277006149,
0.0143447127... |
d821a286-e3d5-583b-8286-29490c962fd4 | /documentation/search-evaluation/pipeline-output-quality/ | Evaluating Pipeline Output Quality | Wrapping Up | documentation | false | Evaluating Pipeline Output Quality > Wrapping Up
You now have a Ragas-based scoring loop for the full RAG pipeline, a 2x2 to attribute regressions to retrieval or generation, and a CI pattern to gate releases on `faithfulness`, `answer_relevancy`, and `context_precision`. | [
-0.0012756437063217163,
-0.0061127301305532455,
-0.025048770010471344,
-0.05954382196068764,
0.04852534830570221,
-0.029737437143921852,
0.05411243438720703,
0.03937888890504837,
0.054457034915685654,
-0.04469602555036545,
0.024010730907320976,
0.01873643323779106,
0.10563823580741882,
-0.... |
d84d033d-14ae-5dc3-9a59-383e07513f33 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Tune Weights Last | documentation | false | How to Tune Hybrid Search in Qdrant > Tune Weights Last
A weight pair gives one multiplier to each prefetch, in the order the prefetches appear in the query. The pair is absolute, so `(1, 2)` and `(2, 4)` are two different settings: the formula divides the position by the weight, so scaling both weights changes every ... | [
0.0356525257229805,
-0.0173109732568264,
-0.07002808898687363,
-0.014413727447390556,
0.07118017226457596,
-0.05040134862065315,
0.011337860487401485,
0.033557064831256866,
0.04974189028143883,
-0.022416938096284866,
-0.0025829309597611427,
0.030054431408643723,
0.040397342294454575,
-0.00... |
d86b728b-049b-560f-806d-1d8f7f90834c | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | documentation | false | Multimodal Food Search Demo
| Time: 20 min | Level: Beginner | Output: [GitHub](https://github.com/qdrant/demo-food-discovery/) |
| --- | ----------- | ----------- |
Not every search journey begins with a specific destination in mind. Sometimes, you just want to explore and see what’s out there and what you might lik... | [
0.037593256682157516,
-0.062264714390039444,
-0.044470638036727905,
-0.0026796418242156506,
0.09385021030902863,
-0.023975206539034843,
0.05801987648010254,
0.02975527197122574,
0.05541030317544937,
-0.007935457862913609,
0.019675282761454582,
0.021175596863031387,
0.06127731502056122,
-0.... | |
d8799d00-a2a8-5648-8c50-981edbb0cf63 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types | documentation | false | API Reference > qdrant.io/v1 > Resource Types
- [QdrantCloudRegion](#qdrantcloudregion)
- [QdrantCloudRegionList](#qdrantcloudregionlist)
- [QdrantCluster](#qdrantcluster)
- [QdrantClusterList](#qdrantclusterlist)
- [QdrantClusterRestore](#qdrantclusterrestore)
- [QdrantClusterRestoreList](#qdrantclusterrestorelist)
-... | [
0.04221136122941971,
-0.00990371685475111,
-0.003884643781930208,
-0.07873125374317169,
0.060630589723587036,
-0.0322549045085907,
0.04153350740671158,
0.025811059400439262,
0.06424020975828171,
-0.06647428125143051,
0.07521534711122513,
0.014623327180743217,
0.06456617265939713,
-0.007750... |
d886f956-124a-52fa-ae0a-ca406e7cba3e | /course/essentials/day-1/chunking-strategies/ | Text Chunking Strategies | From Raw Text to Search-Ready > The Problem with Whole Documents | course | false | Text Chunking Strategies > From Raw Text to Search-Ready > The Problem with Whole Documents
**With Proper Chunking:**
- The guide is split into topic-focused chunks (e.g., one for HNSW parameters).
- The chunk about the `m` parameter gets its own precise vector.
- Qdrant easily retrieves this specific chunk, providing... | [
0.018513111397624016,
-0.04994978383183479,
-0.073983334004879,
-0.046491436660289764,
0.054560981690883636,
-0.03983468934893608,
0.03633062168955803,
0.029586048796772957,
0.07612919807434082,
-0.018562743440270424,
0.02189997024834156,
0.0017132278298959136,
0.07108520716428757,
-0.0296... |
d89984a2-66da-5fc6-967d-6b4ebaa30bc9 | /documentation/hybrid-cloud/hybrid-cloud-setup/ | Setup Hybrid Cloud | Deleting a Hybrid Cloud Environment | documentation | true | Setup Hybrid Cloud > Deleting a Hybrid Cloud Environment
To delete a Hybrid Cloud Environment, first delete all Qdrant database clusters in it. Then you can delete the environment itself.
To clean up your Kubernetes cluster, after deleting the Hybrid Cloud Environment, you can download the script from https://github.... | [
0.058304887264966965,
-0.005178022664040327,
-0.028668509796261787,
-0.053990043699741364,
0.0422549769282341,
-0.0008616690174676478,
0.0381789468228817,
0.026852965354919434,
0.057277876883745193,
-0.041669733822345734,
0.026642948389053345,
0.006227851379662752,
0.051450464874506,
-0.00... |
d8b30aed-3303-558f-bffd-96b4a748952d | /documentation/manage-data/storage/ | Storage | Payload storage | documentation | false | Storage > Payload storage
Qdrant supports two [memory tiers](/documentation/ops-configuration/memory-tiers/) for payloads: `cached` and `cold` (default). Disk and [Gridstore](/articles/gridstore-key-value-storage/) are used for persistence regardless of tier.
`cached` payload storage is organized in the same way as `... | [
0.02040852978825569,
-0.01949872076511383,
-0.022293178364634514,
-0.034151189029216766,
0.05851459503173828,
-0.029572878032922745,
0.058641523122787476,
0.022693857550621033,
0.09359145164489746,
-0.022290440276265144,
0.021258996799588203,
-0.005412502679973841,
0.036561835557222366,
-0... |
d8c7fbbe-ca8b-51c1-abb6-ae1ab9a06337 | /course/beginners/module-3/the-two-families-of-search/ | The Two Families of Search | Sparse Search > Sparse Models | course | false | The Two Families of Search > Sparse Search > Sparse Models
This module uses BM25, a statistical scoring method that requires no training. It scores the terms already present in the text.
Two trained models extend BM25:
- **SPLADE** expands the text with related terms, allowing a document to match a query even when t... | [
0.039110083132982254,
-0.048071470111608505,
-0.032227523624897,
-0.03358446806669235,
0.04763620346784592,
-0.05591953173279762,
0.07552749663591385,
0.02970895916223526,
0.03926844522356987,
0.002155786147341132,
0.04481170326471329,
0.045192599296569824,
0.05110396817326546,
0.020127112... |
d8ca6c43-763a-5b91-8dcc-4104952d42ac | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 2: Statistical Sampling (Recommended) > Recall@k | documentation | true | Search Quality > Tier 2: Statistical Sampling (Recommended) > Recall@k
Recall@k measures: "Of the top-k results from the source system, what fraction also appears in Qdrant's top-k?"
```py
def recall_at_k(source_results, qdrant_results, k):
"""Compute recall@k: fraction of source top-k present in Qdrant top-k."""... | [
0.04493817314505577,
-0.06241562217473984,
-0.0523686408996582,
-0.05550207942724228,
0.07067036628723145,
-0.0053813522681593895,
0.06256729364395142,
0.043013568967580795,
0.12108320742845535,
-0.024360306560993195,
0.04474401846528053,
-0.0059425304643809795,
0.08289791643619537,
-0.019... |
d8cd9ddb-0849-55ad-89ac-3d6588e42539 | /documentation/search/text-search/sparse-vector-search/ | Sparse Vector Search | BM25 | documentation | true | Sparse Vector Search > BM25
We recommend running BM25 on a full-text index rather than on sparse vectors. A full-text index with scoring enabled computes the average document length from your data, works on text already stored in the payload, and doesn't require generating embeddings.
You can also run [BM25](/documen... | [
0.04348040372133255,
-0.03386538103222847,
-0.020720964297652245,
-0.036009207367897034,
0.04850839823484421,
-0.04493558406829834,
0.08521413803100586,
0.036426812410354614,
0.03182388097047806,
-0.012461991980671883,
0.04354679584503174,
0.04537268355488777,
0.012923534028232098,
-0.0332... |
d8dd7dff-19e2-560a-8d5d-cded1b1dc820 | /documentation/examples/multitenancy/ | Multitenancy with Qdrant | Querying documents with constraints | documentation | true | Multitenancy with Qdrant > Querying documents with constraints
Let's assume we are searching for some information about vector search, but are only allowed to
use Qdrant documentation. Every query embeds the question with the same model and adds a filter on the
`library` field, so only the points of one tenant are sea... | [
0.04831681773066521,
-0.06516796350479126,
-0.047781769186258316,
-0.01113076787441969,
0.04916806519031525,
-0.0478304885327816,
0.08738557994365692,
0.03665882721543312,
0.06704985350370407,
-0.015360772609710693,
0.028560340404510498,
0.03539567440748215,
0.06313320249319077,
-0.0212596... |
d8ec56c7-b979-593b-8f72-b33f2c88e518 | /articles/memory-consumption/ | Minimal RAM to Serve 1M Vectors | How to speed up the search | article | false | Minimal RAM to Serve 1M Vectors > How to speed up the search
With the production-grade disk, the search speed could be even higher.
Some configurations of the SSDs can reach 1M IOPS and more.
Which might be an interesting option to serve large datasets with low search latency in Qdrant. | [
0.012272953987121582,
-0.07464195042848587,
-0.040437228977680206,
-0.017766958102583885,
0.07776817679405212,
-0.036352358758449554,
0.06065313518047333,
0.009356124326586723,
0.09235876053571701,
-0.004857032559812069,
-0.0013966956175863743,
0.014107496477663517,
0.07416678220033646,
-0... |
d8f65a02-5574-5654-804b-11817116c1cf | /documentation/embeddings/upstage/ | Upstage | Embed Documents | documentation | true | Upstage > Embed Documents
Embed documents with the passage model. One request embeds a list of inputs, and each item in the response carries the `index` of its input, which this example uses as the point ID:
```python
documents = [
"Qdrant is a vector search engine.",
"Upstage Solar Embedding models turn text... | [
0.021388350054621696,
-0.03887774050235748,
-0.031717635691165924,
-0.06063556298613548,
0.08016186207532883,
-0.04698488116264343,
0.05357427895069122,
0.08095267415046692,
0.08354002982378006,
-0.01722599007189274,
0.033999599516391754,
0.020624957978725433,
0.026042979210615158,
-0.0519... |
d901c251-7830-5a8e-a0a3-04ded788919d | /documentation/manage-data/collections/ | Collections | Setting Up Multitenancy | documentation | false | Collections > Setting Up Multitenancy
**How many collections should you create?** In most cases, you should only use a single collection with payload-based partitioning. This approach is called [multitenancy](https://en.wikipedia.org/wiki/Multitenancy). It is efficient for most of users, but it requires additional con... | [
-0.011074508540332317,
-0.009443705901503563,
-0.045855507254600525,
-0.02619365230202675,
0.0436551496386528,
-0.07972776144742966,
-0.0015467205084860325,
0.039484698325395584,
0.08843450248241425,
-0.045221030712127686,
-0.005660561379045248,
0.03218968212604523,
0.06183560565114021,
-0... |
d91a985c-2694-5c90-9204-d28f6195592a | /course/multi-vector-search/module-1/use-cases-multi-vector/ | Use Cases for Multi-Vector Search | Conclusion | course | false | Use Cases for Multi-Vector Search > Conclusion
Multi-vector search excels at **fine-grained matching** - scenarios where you need to verify that ALL aspects of a query are present in a document, not just that they're topically related. By preserving token-level information rather than averaging it away, ColBERT and ot... | [
0.014952202327549458,
-0.05047629028558731,
-0.03991865739226341,
-0.048158783465623856,
0.07723798602819443,
-0.024981437250971794,
0.044078096747398376,
0.019688326865434647,
0.06757137179374695,
-0.0462464913725853,
0.013672467321157455,
0.028331618756055832,
0.0761195570230484,
-0.0203... |
d92a393c-e41c-5187-8dee-370764f63a76 | /articles/what-is-a-vector-database/ | What is a Vector Database? | The Architecture of a Vector Database > Points > 1. The ID: The Point's Unique Identifier | article | false | What is a Vector Database? > The Architecture of a Vector Database > Points > 1. The ID: The Point's Unique Identifier
Just like in a relational database, each point in a vector database gets a unique ID that ensures it can be easily found later. When a vector is added to the database, the ID is created automatically.... | [
0.03481635823845863,
-0.07319246977567673,
-0.05645081028342247,
-0.024999037384986877,
0.051763780415058136,
-0.009547742083668709,
0.03579460456967354,
0.050784412771463394,
0.08095166087150574,
-0.02094782330095768,
0.028213020414114,
0.02615010179579258,
0.03942669928073883,
0.00478643... |
d937dd85-f428-5628-9a18-c9d336856689 | /documentation/private-cloud/changelog/ | Changelog | 1.9.12 (2026-07-17) | documentation | false | Changelog > 1.9.12 (2026-07-17)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.37.1 |
| operator | 2.34.0 |
| qdrant-cluster-manager | v0.3.19 |
| qdrant-cluster-exporter | 1.8.0 |
Latest validated Qdrant version: 1.18.2
* Updated operato... | [
0.058519624173641205,
-0.020310141146183014,
-0.059790872037410736,
-0.003985891118645668,
0.05602844059467316,
-0.050404153764247894,
0.011486114002764225,
0.04385260492563248,
0.041277721524238586,
-0.04854929447174072,
0.031659528613090515,
0.023163896054029465,
0.05092965066432953,
-0.... |
d95bd974-2ca4-5515-9ea8-3ac52d7c3adf | /documentation/cloud/inference/ | Inference | Using Inference | documentation | false | Inference > Using Inference
Use inference through the Qdrant SDKs and the REST or gRPC APIs when upserting points and when querying the database. Refer to the [Inference documentation](/documentation/inference/) for details. | [
0.03665347024798393,
-0.04846785590052605,
0.006986234802752733,
-0.038105838000774384,
0.06122995540499687,
-0.03438768908381462,
0.08380141109228134,
0.05791032314300537,
0.06240784749388695,
-0.0038084073457866907,
0.03635941445827484,
0.010306436568498611,
0.05963345989584923,
-0.03031... |
d96270f5-57af-5f0c-a028-b68d2a1454aa | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | Testing Gridstore Performance: Benchmarks > The results speak for themselves: | article | false | Introducing Gridstore: Qdrant's Custom Key-Value Store > Testing Gridstore Performance: Benchmarks > The results speak for themselves:
Average latency for all kinds of workloads is lower across the board, particularly for inserts.
,
a technique of reducing the memory footprint by even four times, by using `int8` to represent
the values that would be normally represented by `float32`.
The memory usage in [vector search... | [
0.07121916115283966,
-0.05654917657375336,
-0.05004887282848358,
-0.043566398322582245,
0.03136037662625313,
-0.007129829842597246,
0.058900341391563416,
0.024390291422605515,
0.11383173614740372,
-0.00944159459322691,
0.04878058284521103,
0.00648509431630373,
0.05008344724774361,
-0.03597... | |
d9a9e2d6-52ab-56f6-9f06-8bc3d3c6812d | /documentation/manage-data/collections/ | Collections | Collection Info > Approximate Point and Vector Counts | documentation | false | Collections > Collection Info > Approximate Point and Vector Counts
You may be interested in the count attributes:
- `points_count` - total number of objects (vectors and their payloads) stored in the collection
- `indexed_vectors_count` - total number of vectors stored in the HNSW or sparse index. Qdrant does not st... | [
0.026358576491475105,
-0.0428217351436615,
-0.031434766948223114,
-0.015859754756093025,
0.04121227189898491,
-0.02539416030049324,
0.03918875381350517,
0.051092710345983505,
0.08530770242214203,
-0.037702273577451706,
0.018348783254623413,
0.023100832477211952,
0.051949549466371536,
-0.00... |
d9c25cec-8f0d-5b6d-97e8-06ba3611b1e5 | /course/essentials/day-5/ | Day 5: Advanced APIs | course | false | Day 5: Advanced APIs
Day 5
Multi‑vector patterns and the Universal Query API.
---
## Today’s path
1. Multivectors for Late Interaction Models
2. The Universal Query API
3. Demo: Universal Query for Hybrid Retrieval
4. Project: Building a Recommendation System
You’ll synthesize these APIs into a practical recommen... | [
0.02822522260248661,
-0.004788800608366728,
-0.01922544278204441,
-0.03175681456923485,
0.04360131919384003,
-0.04238513857126236,
0.04485560953617096,
0.04141450300812721,
0.08640676736831665,
-0.03910721465945244,
0.04139772430062294,
0.07298123091459274,
0.05693056806921959,
-0.06028218... | |
d9d383c0-741d-5e8d-a167-0f4cbf092dcc | /course/beginners/module-4/design-your-own-system/ | Design Your Own System | course | false | Design Your Own System
Module 4
Use these five questions to design a system of your own:
1. **What do the queries look like?** Plain language, exact strings such as codes and IDs, or both. If you need both, use hybrid search, from Module 3.
2. **Which fields must every search filter on?** That list is your payload s... | [
0.03759963810443878,
-0.04727655276656151,
-0.07320660352706909,
-0.008636157028377056,
0.09041231870651245,
-0.02752106264233589,
0.03226575627923012,
0.0359092578291893,
0.062055137008428574,
-0.03143135830760002,
0.023476196452975273,
0.016880881041288376,
0.04577192664146423,
-0.044372... | |
d9dc300e-dd49-5fcf-862e-f5862da13124 | /documentation/cloud/ | Managed Cloud | documentation | false | Managed Cloud
Qdrant Managed Cloud is our SaaS (software-as-a-service) solution, providing managed Qdrant database clusters on the cloud. We provide you the same fast and reliable similarity search engine, but without the need to maintain your own infrastructure.
Transitioning to the Managed Cloud version of Qdrant d... | [
-0.001629763632081449,
-0.012103060260415077,
-0.08793000876903534,
-0.05020448565483093,
0.046062763780355453,
-0.05032378062605858,
0.07322315126657486,
0.029390309005975723,
0.054248131811618805,
-0.052251119166612625,
0.010799144394695759,
0.013137572444975376,
0.031041784211993217,
-0... | |
d9edb18c-005c-52b1-ad65-771e7928d3d6 | /documentation/cloud-premium/ | Premium Tier | Private Network Connectivity | documentation | false | Premium Tier > Private Network Connectivity
Premium clusters can accept traffic from your own virtual network over AWS PrivateLink, GCP Private Service Connect, or Azure Private Link. Traffic between your application and the cluster then stays on the cloud provider's network instead of crossing the public internet.
T... | [
0.013059236109256744,
-0.026843473315238953,
-0.06560830771923065,
-0.003544442355632782,
0.03924356400966644,
-0.021917302161455154,
0.04853503778576851,
0.05411114543676376,
0.012761682271957397,
-0.001901355106383562,
0.03771200776100159,
0.003966775257140398,
0.01218023058027029,
-0.03... |
d9f64bbc-ef91-5ef3-b9e6-5ffe0294326d | /documentation/manage-data/quantization/ | Quantization | TurboQuant Quantization | documentation | false | Quantization > TurboQuant Quantization
*Available as of v1.18.0*
TurboQuant is [a quantization method developed by Google](https://research.google/blog/turboquant-redefining-ai-efficiency-with-extreme-compression/). It operates by applying a fast random rotation to vectors before compression, which evenly redistribut... | [
0.012098888866603374,
-0.041810061782598495,
-0.04812438040971756,
-0.04965502768754959,
0.028649967163801193,
0.03398038074374199,
0.10768798738718033,
0.02285047061741352,
0.07231301814317703,
-0.03456713259220123,
0.0453474335372448,
0.030058305710554123,
0.028361449018120766,
-0.033562... |
d9fc386a-1d1e-5de1-aac9-174e134d2292 | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Feedback-Based Scoring > The Math of Edge Cases | article | false | Relevance Feedback in Qdrant > Feedback-Based Scoring > The Math of Edge Cases
**Direction’s delta is zero**
If the retriever sees the positive and the negative documents (from the context pair) as equally similar to the candidate document, there’s no direction-establishing signal.
**Context pair's confidence is ze... | [
0.03301362320780754,
-0.04443436115980148,
-0.046578094363212585,
-0.020274857059121132,
0.030217057093977928,
0.003864303696900606,
0.06426732242107391,
0.018685374408960342,
0.05754668265581131,
-0.014770125970244408,
-0.002918276935815811,
-0.0005255797295831144,
0.07227647304534912,
-0... |
da31d445-bfd8-5a22-b530-f668a60e0c35 | /documentation/migration-guidance/ | Migration Guidance | documentation | false | Migration Guidance
Switching databases is often necessary to improve the performance and costs of large software systems. As the size of data continues to grow, navigating this migration can be tricky. While a migration might appear to have been successful, several silent errors may be occurring. Some examples include... | [
0.027582433074712753,
-0.052220627665519714,
-0.07043758779764175,
-0.027166428044438362,
0.020614441484212875,
-0.028318794444203377,
0.08656325191259384,
0.04669913277029991,
0.04764021933078766,
-0.012619403190910816,
0.00046018397551961243,
0.013240784406661987,
0.04366077482700348,
-0... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.