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 |
|---|---|---|---|---|---|---|---|
169dd769-d7fe-5d20-b312-046d01f0314c | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Vectors > What is the maximum size of vector metadata that can be stored? | documentation | false | Qdrant Fundamentals > Vectors > What is the maximum size of vector metadata that can be stored?
There is no inherent limitation on metadata size, but it should be [optimized for performance and resource usage](/documentation/ops-optimization/optimize/). Users can set upper limits in the configuration.
### Can the sam... | [
-0.0032531418837606907,
-0.02974771149456501,
-0.06631411612033844,
-0.023358535021543503,
0.04427707940340042,
-0.06948333978652954,
0.051433540880680084,
0.03672816976904869,
0.07740578055381775,
-0.04230750724673271,
0.013556179590523243,
0.008209511637687683,
0.08330104500055313,
-0.05... |
16a40f10-ceda-52f5-ab18-bef31bb3192e | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 2: Transactional Outbox Pattern > What This Approach Gets Right | documentation | true | Keeping Postgres and Qdrant in Sync > Tier 2: Transactional Outbox Pattern > What This Approach Gets Right
The write path is completely decoupled from Qdrant. If Qdrant is down for an hour, writes succeed normally and events queue up. When Qdrant comes back, the worker drains the queue. The application never blocks on... | [
0.03603013604879379,
-0.04584243521094322,
0.005345672369003296,
0.0024087836500257254,
0.032499589025974274,
-0.07747777551412582,
0.0544605478644371,
0.012053514830768108,
0.06580076366662979,
-0.009197459556162357,
0.01887030340731144,
0.03633151948451996,
0.03603304177522659,
-0.035341... |
16b6bc2a-15de-562b-b707-f36071791e05 | /articles/what-is-vector-quantization/ | What is Vector Quantization? | Distributing Resources Between Disk & Memory | article | true | What is Vector Quantization? > Distributing Resources Between Disk & Memory
Qdrant stores both the quantized and original vectors. When you enable quantization, both the original and quantized vectors are stored in RAM by default. You can move the original vectors to disk to significantly reduce RAM usage and lower sy... | [
0.039600543677806854,
-0.06542084366083145,
-0.021891098469495773,
-0.0259760320186615,
0.05060411989688873,
0.0033020516857504845,
0.06707103550434113,
0.027788972482085228,
0.11279662698507309,
-0.032447878271341324,
0.0067856162786483765,
0.004309194628149271,
0.057436928153038025,
-0.0... |
16d1c303-0285-55a2-8168-cd0a51cd814a | /course/multi-vector-search/module-2/visual-interpretability/ | Visual Interpretability of ColPali | Creating Heatmap Visualizations | course | true | Visual Interpretability of ColPali > Creating Heatmap Visualizations
To visualize the similarity maps, we need to:
1. Upsample the 32×32 map to match the image dimensions
2. Overlay it as a semi-transparent heatmap on the original image
### Step 3: Upsample and Overlay
```python
from scipy.ndimage import zoom
import... | [
0.04800451546907425,
-0.05721466615796089,
-0.0648610070347786,
-0.06569325178861618,
0.062506765127182,
-0.013123552314937115,
0.04666099697351456,
0.06231085583567619,
0.0029617929831147194,
-0.029702499508857727,
0.07666584104299545,
-0.011485213413834572,
0.10269873589277267,
-0.014678... |
1705e23b-e6c0-58a2-a172-9e4470dd3cfa | /documentation/manage-data/points/ | Points | Upload Points > Sparse Vectors | documentation | true | Points > Upload Points > Sparse Vectors
_Available as of v1.7.0_
Points can contain dense and sparse vectors.
A sparse vector is an array in which most of the elements have a value of zero.
It is possible to take advantage of this property to have an optimized representation, for this reason they have a different s... | [
0.03459042310714722,
-0.03446337580680847,
-0.02789486199617386,
-0.03640192002058029,
0.05926081910729408,
-0.03942256048321724,
0.05666070431470871,
0.04915018752217293,
0.08379558473825455,
-0.03615435212850571,
0.018669703975319862,
0.036515071988105774,
0.044864993542432785,
0.0137416... |
170eb31b-9d95-588f-bf24-5db839a5e3ad | /documentation/tutorials-search-engineering/multi-representation-search/ | Multi-Representation Search | Collection Schema | documentation | true | Multi-Representation Search > Collection Schema
Design the collection before writing any queries. The point granularity is the chunk: every chunk of every paper becomes one point. Title and abstract embeddings are stored on every chunk so the Query API can fuse across them in a single request without an extra lookup.
... | [
0.018505685031414032,
-0.04143953323364258,
-0.05188550055027008,
-0.019570203498005867,
0.06775667518377304,
-0.039766378700733185,
0.060881443321704865,
0.05732756853103638,
0.06591303646564484,
-0.05266617238521576,
0.03719405084848404,
0.045765407383441925,
0.0367780365049839,
-0.02767... |
172c8c07-4fac-5824-9f01-44967f5dcf69 | /course/essentials/day-1/distance-metrics/ | Distance Metrics | Quick rule of thumb | course | false | Distance Metrics > Quick rule of thumb
Most users do **not** need to design a distance metric from scratch:
- If you use a **third-party embedding model** (OpenAI, Cohere, Hugging Face, etc.):
- Use the distance metric recommended in the model docs (often cosine or dot product).
- Create your Qdrant collection wi... | [
0.03292672336101532,
-0.02048247493803501,
-0.022697774693369865,
-0.015434070490300655,
0.04752996563911438,
-0.031246457248926163,
0.0321957990527153,
0.0416233204305172,
0.06735698878765106,
-0.04434235021471977,
0.03852182999253273,
0.004876846447587013,
0.05362117290496826,
-0.0230816... |
17446e36-6511-5f3f-a686-a128ddb78b8d | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Scalar Quantization > Theoretical Background | article | false | Scalar Quantization for Vector Search > Scalar Quantization > Theoretical Background
Assume we have a collection of `float32` vectors and denote a single value as `f32`.
In reality neural embeddings do not cover a whole range represented by the floating
point numbers, but rather a small subrange. Since we know all th... | [
0.0425291433930397,
-0.02418726682662964,
-0.041074007749557495,
-0.03172433748841286,
0.04052918404340744,
-0.025047145783901215,
0.05022088438272476,
0.050208475440740585,
0.09067495167255402,
-0.007408213801681995,
0.03987560048699379,
0.017489800229668617,
0.08427786082029343,
-0.01303... |
174dddbb-e7b5-51c1-beba-6b2eb2ab914e | /course/beginners/module-2/core-data-model/ | Core Data Model | Point | course | false | Core Data Model > Point
The atomic unit of data. Every point has an ID (integer or UUID), a vector, and an optional payload. Points are what you search, retrieve, and filter. | [
0.01269038300961256,
-0.01897374726831913,
-0.06150525063276291,
-0.05345159396529198,
0.05875178053975105,
0.0022888730745762587,
0.0368531234562397,
0.05958845466375351,
0.09665322303771973,
-0.011507241055369377,
0.034004829823970795,
0.024988293647766113,
0.04105374962091446,
-0.015104... |
1775d0fd-770d-5843-8e2d-dc527f38ca53 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantCloudRegion | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantCloudRegion
QdrantCloudRegion is the Schema for the qdrantcloudregions API
_Appears in:_
- [QdrantCloudRegionList](#qdrantcloudregionlist)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `k... | [
0.03153998404741287,
-0.010237254202365875,
-0.026157580316066742,
-0.07519888132810593,
0.07909787446260452,
-0.03862730786204338,
0.0757799968123436,
0.06709039211273193,
0.04309086874127388,
-0.04246433079242706,
0.03919301927089691,
0.006785910576581955,
0.05643800273537636,
-0.0313556... |
177a4500-7a6b-532c-af8f-ebb402eea784 | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Sharding > User-Defined Sharding | documentation | false | Distributed Deployment > Sharding > User-Defined Sharding
*Available as of v1.7.0*
Qdrant allows you to specify the shard for each point individually. This feature is useful if you want to control the shard placement of your data, so that operations can hit only the subset of shards they actually need. In big cluster... | [
0.029691891744732857,
-0.03954004496335983,
-0.052280571311712265,
-0.04496986046433449,
0.0477224662899971,
-0.04824762046337128,
0.057541247457265854,
0.04452291131019592,
0.08060458302497864,
-0.005425852723419666,
0.04716833308339119,
0.007363170385360718,
0.05420367792248726,
-0.01498... |
177c9736-6f80-565b-ac13-222655124042 | /documentation/examples/hybrid-search-llamaindex-jinaai/ | Chat With Product PDF Manuals Using Hybrid Search | documentation | false | Chat With Product PDF Manuals Using Hybrid Search
| Time: 60 min | Level: Advanced | Stack: Python, LlamaIndex, Jina | Output: [GitHub](https://github.com/qdrant/examples/blob/Update-example-Chat-With-Product-PDF-Manuals/Chat%20With%20Product%20PDF%20Manuals%20Using%20Hybrid%20Search/HC_DO_LlamaIndex_Jina_v2.ipynb) | ... | [
0.0011206450872123241,
-0.029182683676481247,
-0.07887381315231323,
-0.0758250281214714,
0.10323634743690491,
-0.04071058705449104,
0.04171253368258476,
0.04697506129741669,
0.07442334294319153,
-0.02167471870779991,
0.015317514538764954,
0.0074250721372663975,
0.05996072292327881,
-0.0264... | |
17a04168-f7a0-5363-bee9-f05fbb9803db | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | Step 7: Create Query Embeddings | course | true | Demo: HNSW Performance Tuning > Step 7: Create Query Embeddings
We need to use the same model and dimensions as our dataset to ensure compatibility.
If you do not have an OpenAI key, use the commented fallback below.
```python
# Optional fallback without an API key:
# import requests
# test_query = "artificial intel... | [
0.030369820073246956,
-0.020301206037402153,
-0.0314972810447216,
-0.0633683055639267,
0.04484841600060463,
-0.06191948801279068,
0.04974622651934624,
0.10433097183704376,
0.04608070105314255,
-0.012549415230751038,
0.0341527946293354,
0.021350737661123276,
0.05616779625415802,
-0.07280192... |
17b85d4b-5a62-5df8-befb-39b039ab9588 | /documentation/search-evaluation/retrieval-relevance/ | Measuring Retrieval Relevance | Using the Golden Set | documentation | true | Measuring Retrieval Relevance > Using the Golden Set
ranx is a Python library for ranking-metric evaluation. It covers the standard ranking metrics (`recall@k`, `MRR`, `NDCG@k`, `Precision@k`, MAP, and others) through one consistent interface, so you don't hand-roll each metric or juggle different libraries as needs g... | [
0.05620601773262024,
-0.03887704014778137,
-0.043596457690000534,
-0.017526451498270035,
0.08707135915756226,
-0.026134712621569633,
0.06832053512334824,
0.03731527924537659,
0.0682918131351471,
-0.03542500361800194,
0.02273179218173027,
-0.021694155409932137,
0.04610768333077431,
-0.00143... |
17dda529-2a8b-5a5d-a8b1-f4fd5b7828ad | /documentation/tutorials-operations/gpu-accelerated-hnsw-indexing/ | GPU-Accelerated HNSW Indexing | Monitoring Indexing and Query Latency > Run Both Coroutines | documentation | true | GPU-Accelerated HNSW Indexing > Monitoring Indexing and Query Latency > Run Both Coroutines
Kick off `consume_optimizations` and `query` as concurrent tasks sharing the same `event`, wait for both to finish, then save the results to disk:
```python
import json
OPTIMIZATIONS_FILE = "optimizations.jsonl"
LATENCIES_FIL... | [
0.012164491228759289,
-0.03609520569443703,
-0.05571741238236427,
-0.038679465651512146,
0.05950906500220299,
-0.04543396085500717,
0.0721336379647255,
0.014654482714831829,
0.06853198260068893,
-0.03336548060178757,
0.07625482976436615,
0.006441987119615078,
0.04862380027770996,
-0.005589... |
17defd51-f13e-5b18-b46d-6a81da9b99ff | /course/essentials/day-5/colbert-multivectors/ | Multivectors for Late Interaction Models | Late Interaction: Token-Level Precision | course | false | Multivectors for Late Interaction Models > Late Interaction: Token-Level Precision
Qdrant implements this powerful technique through [multivector representations](/documentation/manage-data/vectors/#multivectors). A multivector field holds an ordered list of subvectors, each of which captures a different token of the ... | [
0.06819787621498108,
-0.019976302981376648,
-0.02300945296883583,
-0.045368779450654984,
0.055821698158979416,
-0.058434441685676575,
0.07891615480184555,
0.019528213888406754,
0.0659826472401619,
-0.04333768039941788,
0.04401494190096855,
0.031029721722006798,
0.06915254145860672,
-0.0210... |
17e90936-8ba4-5a14-92e4-ccc9ef4a9e17 | /articles/what-is-a-vector-database/ | What is a Vector Database? | Hybrid Search > Fusion | article | false | What is a Vector Database? > Hybrid Search > Fusion
Qdrant uses **normalization** and **fusion** techniques to blend results from multiple search methods, such as dense and sparse. One common approach is **Reciprocal Rank Fusion (RRF)**, where results from different methods are merged, giving higher importance to item... | [
0.059946492314338684,
-0.04871193319559097,
-0.07078858464956284,
-0.05856684222817421,
0.06564824283123016,
-0.03931674361228943,
0.1029546707868576,
0.02145644836127758,
0.07870008796453476,
-0.027269873768091202,
0.04741763696074486,
-0.000006307038347586058,
0.06986967474222183,
-0.000... |
17f8a8a1-1a82-5724-959b-f29de065ca3b | /articles/memory-consumption/ | Minimal RAM to Serve 1M Vectors | How to measure actual RAM requirements | article | true | Minimal RAM to Serve 1M Vectors > How to measure actual RAM requirements
<!--
1. We need to know how much RAM we need to have for the program to work, so why not just do a straightforward experiment.
2. Let's limit the allowed memory of the process and see at which point the process will working.
3. We can do a grid s... | [
0.006399636622518301,
-0.0866873636841774,
-0.020514868199825287,
-0.015801671892404556,
0.07797013223171234,
-0.00477569829672575,
0.04699675366282463,
0.04216146096587181,
0.10900477319955826,
-0.003280353732407093,
0.007062801159918308,
0.023398956283926964,
0.06602568924427032,
-0.0443... |
18521ce5-b5ae-5769-92c2-fb8f71b2ad02 | /course/multi-vector-search/module-3/quantization-techniques/ | Vector Quantization Techniques | Search-Time Control with Rescoring | course | true | Vector Quantization Techniques > Search-Time Control with Rescoring
Qdrant provides **automatic rescoring**: the quantized index quickly finds candidates, then re-ranks them using the original float32 vectors for accuracy.
**Key search parameters:**
- `rescore`: Re-evaluate top candidates with original vectors (defau... | [
0.05121977627277374,
-0.046032339334487915,
-0.021963579580187798,
-0.018367763608694077,
0.07432876527309418,
-0.007793894968926907,
0.05029497295618057,
-0.013312463648617268,
0.0871136486530304,
-0.034767523407936096,
0.037168264389038086,
-0.004642185289412737,
0.07862403988838196,
-0.... |
185d4516-d40e-5bae-9e25-b7a30871c981 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 1. How Can You Get the Best Search Performance? > Ensure your hot dataset fits in RAM for low-latency queries. | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 1. How Can You Get the Best Search Performance? > Ensure your hot dataset fits in RAM for low-latency queries.
If not, move the colder structures to a lower [**memory tier**](/documentation/ops-configuration/memory-tiers/). Since Qdrant v1.19, each structure (d... | [
0.04264570027589798,
-0.04568283259868622,
-0.056269045919179916,
-0.015764934942126274,
0.04691223427653313,
-0.04437972232699394,
0.0567837618291378,
0.025047749280929565,
0.0966227650642395,
-0.019417017698287964,
0.02334756776690483,
0.015598265454173088,
0.05600869655609131,
-0.010088... |
1865d6a4-8f7e-5285-b051-46391c8cdd53 | /course/essentials/day-5/pitstop-project/ | Project: Building a Recommendation System | Share Your Discovery | course | true | Project: Building a Recommendation System > Share Your Discovery
### Step 1: Reflect on Your Findings
1. How did the Universal Query API simplify your recommendation pipeline (fewer calls, fewer joins, less code)?
2. Which fusion strategy (RRF vs. DBSF) ranked better for your queries?
3. What was the effect of ColBER... | [
0.018902122974395752,
-0.051204703748226166,
-0.04657575115561485,
-0.022011294960975647,
0.05741477012634277,
-0.03398881107568741,
0.04267747327685356,
0.05080822482705116,
0.060819629579782486,
-0.029738649725914,
0.05492362752556801,
0.0054555912502110004,
0.07827330380678177,
-0.03326... |
187c9097-972f-533d-ad5a-9658b83dbaab | /documentation/tutorials-operations/create-snapshot/ | Snapshots | Prerequisites > Load the dataset | documentation | true | Snapshots > Prerequisites > Load the dataset
We are going to use a dataset with precomputed embeddings, available on Hugging Face Hub. The dataset is called [Qdrant/arxiv-titles-instructorxl-embeddings](https://huggingface.co/datasets/Qdrant/arxiv-titles-instructorxl-embeddings) and was created using the [InstructorXL... | [
0.04857386648654938,
-0.02606578730046749,
-0.044057294726371765,
-0.03342311456799507,
0.08522805571556091,
-0.04865528643131256,
0.028525156900286674,
0.07465773820877075,
0.028182532638311386,
-0.022848743945360184,
0.04384821280837059,
0.014255835674703121,
0.0415710024535656,
-0.02790... |
187d6afa-66e0-5a57-a51d-07e97921ee4f | /articles/muvera-embeddings/ | MUVERA: Making Multivectors More Performant | How MUVERA Embeddings are created | article | false | MUVERA: Making Multivectors More Performant > How MUVERA Embeddings are created
**MUVERA** (**Mu**lti-**Ve**ctor **R**etrieval **A**lgorithm) transforms variable-length sequences of vectors into
fixed-dimensional representations. Since the number of vectors in the input varies between documents and queries, and
migh... | [
0.08126543462276459,
-0.033812426030635834,
-0.06294898688793182,
-0.05952557921409607,
0.06991530954837799,
-0.022853709757328033,
0.06610260158777237,
0.023020431399345398,
0.0525553897023201,
-0.006358215119689703,
0.0011670618550851941,
0.03486071899533272,
0.04950294271111488,
-0.0242... |
1880538c-5683-5c8a-8c5f-6102645b088c | /documentation/tutorials-operations/large-scale-search/ | Large-Scale Search | Memory Usage | documentation | false | Large-Scale Search > Memory Usage
After the upload and indexation process is finished, let's take a detailed look at the memory usage of the Qdrant server.

On the high level, memory usage consists of 3 components:
- System memory - 8.34Gb... | [
0.01988937146961689,
-0.02173660323023796,
-0.013433744199573994,
0.003985293209552765,
0.08729539066553116,
-0.05437655746936798,
0.05853716656565666,
0.04686497151851654,
0.11839522421360016,
-0.05346597358584404,
0.003646104596555233,
0.006524255499243736,
-0.0003681168600451201,
-0.038... |
1893488b-fcab-5719-a430-53c59ee69cb5 | /documentation/platforms/privategpt/ | PrivateGPT | documentation | false | PrivateGPT
[PrivateGPT](https://docs.privategpt.dev/) is a production-ready AI project that allows you to inquire about your documents using Large Language Models (LLMs) with offline support.
PrivateGPT uses Qdrant as the default vectorstore for ingesting and retrieving documents. | [
0.03133143112063408,
-0.01642901636660099,
-0.06343572586774826,
-0.05736387521028519,
0.03183425962924957,
0.010081587359309196,
0.0718892514705658,
0.0418873131275177,
0.07538388669490814,
-0.04893972724676132,
0.04027235135436058,
0.023665742948651314,
0.03410889953374863,
-0.0600151382... | |
18a6dfd8-ce7b-5145-bb7e-130f18c3cecd | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Compare RRF and DBSF on Your Labels | documentation | true | How to Tune Hybrid Search in Qdrant > Compare RRF and DBSF on Your Labels
Use your [labeled query set](/documentation/search-tuning/before-tuning-a-qdrant-collection/#make-sure-your-labels-can-detect-a-gain) to compare RRF and DBSF over the same prefetches. Run RRF at `k=2` and equal weights, then run DBSF.
Both quer... | [
0.0258058812469244,
-0.03157520666718483,
-0.06184248626232147,
-0.04881247878074646,
0.05322655662894249,
-0.05151839926838875,
0.052887674421072006,
0.06888888031244278,
0.060454025864601135,
-0.047848258167505264,
0.03228520229458809,
-0.001939870067872107,
0.015471882186830044,
-0.0124... |
18b5603e-ba2c-5e06-a1c0-0498805cd78b | /documentation/tutorials-search-engineering/branch-aware-search/ | Branch-Aware Search | Setup | documentation | true | Branch-Aware Search > Setup
Each version of a file is one point, embedded with a dense model for semantic search. The [Cloud Quickstart](/documentation/cloud-quickstart/) covers creating a cluster and connecting a client.
This tutorial uses Qdrant Cloud Inference to generate embeddings server-side. The free tier cove... | [
0.03674011677503586,
-0.062358591705560684,
-0.04273856058716774,
-0.031203655526041985,
0.09208258241415024,
-0.04126758500933647,
0.0881287083029747,
0.029109615832567215,
0.05101768672466278,
-0.03816710039973259,
0.02451843023300171,
0.04569610208272934,
0.026850949972867966,
-0.040852... |
18b5da8d-ca0d-5387-abe1-a863c7371963 | /course/beginners/module-2/core-data-model/ | Core Data Model | Collection | course | false | Core Data Model > Collection
Like a table in a relational database. Stores vectors of a fixed size and a chosen distance metric. Every point in a collection must have a vector of the same dimension. | [
0.03121078759431839,
-0.009607896208763123,
-0.046494245529174805,
-0.04574822261929512,
0.03487858176231384,
-0.039061617106199265,
0.05647186189889908,
0.05438893288373947,
0.11118875443935394,
-0.03647855669260025,
0.009183526039123535,
0.03430367261171341,
0.09687104821205139,
0.021730... |
18cb1dcf-bba0-5700-a6f3-ab2551173995 | /course/multi-vector-search/module-1/use-cases-multi-vector/ | Use Cases for Multi-Vector Search | A Concrete Demonstration > Why the Difference? | course | false | Use Cases for Multi-Vector Search > A Concrete Demonstration > Why the Difference?
**Single-vector behavior**: Document C gets inflated scores because it contains many topically-related terms. The averaging process captures "this document is about Python web development and databases" but can't verify whether it actua... | [
0.022624896839261055,
-0.0594559870660305,
-0.045148927718400955,
-0.02326282486319542,
0.058020055294036865,
-0.0016572531312704086,
0.04619252681732178,
0.02484573796391487,
0.09271098673343658,
-0.03311120346188545,
0.0027155904099345207,
0.024780115112662315,
0.06471753865480423,
-0.01... |
18f1b15d-8a6f-5318-9c1d-cc46fbb27702 | /course/essentials/day-2/pitstop-project/ | Project: HNSW Performance Benchmarking | Your Mission | course | false | Project: HNSW Performance Benchmarking > Your Mission
Build on your Day 1 search engine by adding performance optimization. You'll discover which HNSW settings work best for your specific data and queries, and measure the real impact of payload indexing.
**Estimated Time:** 90 minutes | [
0.0040271389298141,
-0.02696991339325905,
-0.02385648712515831,
-0.0048414370976388454,
0.07467249035835266,
-0.04849075898528099,
0.019260428845882416,
0.04828460142016411,
0.07630979269742966,
-0.03258974477648735,
0.04533180594444275,
0.034136004745960236,
0.04615200683474541,
-0.058000... |
19034260-680d-50a1-8ac0-2e739e185e84 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Results > Eval Setup | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Results > Eval Setup
We check our intuition that the model turned out to be useful on [mMARCO](https://huggingface.co/datasets/unicamp-dl/mmarco), the machine-translated MS MARCO passage ranking collection, using its English and Spanish versions.
... | [
0.04617121070623398,
-0.022998327389359474,
-0.06491764634847641,
-0.02095527946949005,
0.045825663954019547,
-0.04161151126027107,
0.054290201514959335,
0.0306478813290596,
0.08424869924783707,
-0.053519509732723236,
-0.014937478117644787,
0.022520584985613823,
0.05416420102119446,
-0.005... |
190eeb25-402e-50dc-883c-358828afcfca | /documentation/scaling/ | Scaling & Resilience | documentation | false | Scaling & Resilience
When you get started with Qdrant, you typically deploy a single node: one server that stores your vectors and handles queries. That's enough for most early-stage workloads, but as your dataset and traffic grow, you'll need to scale. Qdrant gives you two options: give your node more resources (vert... | [
0.03327196463942528,
-0.03216719999909401,
-0.04390140622854233,
-0.03223760798573494,
0.07677335292100906,
-0.042485468089580536,
0.08549904823303223,
0.04442347213625908,
0.06709808111190796,
-0.022879881784319878,
0.04259687289595604,
-0.0009753863560035825,
0.040314629673957825,
-0.014... | |
1915b835-0b22-55d4-a557-230a9dddf70c | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-4/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization | The Data Flywheel | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization > The Data Flywheel
Fine-tuning isn't a one-time investment. It's the start of a compounding loop:
1. **Better model** leads to better rankings
2. **Better rankings** lead to more clicks
3. **More clicks** produce better tr... | [
0.006550652906298637,
-0.045351963490247726,
-0.06754477322101593,
-0.03438616916537285,
0.04139641672372818,
-0.023963823914527893,
0.06707917898893356,
0.012415091507136822,
0.07922564446926117,
-0.012119126506149769,
-0.008139841258525848,
0.03414506837725639,
0.06133980676531792,
-0.04... |
191f596a-e7b3-57c9-8f68-e26c147bec6d | /course/essentials/ | Qdrant Essentials Course | Who it's for | course | false | Qdrant Essentials Course > Who it's for
ML, backend, data, and search engineers building RAG, semantic search, or recommendations. Requires intermediate Python, basic CLI/APIs, and familiarity with embeddings. | [
0.00023335099103860557,
-0.030864039435982704,
-0.06628293544054031,
-0.018287116661667824,
0.06040823832154274,
-0.05959239974617958,
0.04315141215920448,
0.0638759657740593,
0.05799175426363945,
-0.03181775286793709,
0.04528680816292763,
0.03460013493895531,
0.08612832427024841,
-0.04898... |
19264264-7a51-582c-a5a2-8280fcf1e5b5 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-3/ | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment | Conclusion | documentation | false | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment > Conclusion
Thanks for following along through all three parts. You've built an end-to-end real-time video anomaly detection platform and learned how Qdrant vector search, Twelve Labs video understanding, NVIDIA Metropolis VSS, and Vultr Cloud GPUs c... | [
0.03388114646077156,
-0.030884362757205963,
-0.10591357946395874,
-0.029518060386180878,
0.043322037905454636,
-0.008401925675570965,
0.05819001421332359,
0.014197037555277348,
0.07716742902994156,
-0.040797024965286255,
0.051520559936761856,
0.00870488490909338,
0.03738049417734146,
-0.02... |
19545cb2-646c-50dd-836a-2670b00211b5 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Index > Index Complexity | article | false | Why Vector Search Needs a Dedicated Database > Vector Index > Index Complexity
[**HNSW**](/documentation/manage-data/indexing/) is structured as a multi-layered graph. With a new data point inserted, the algorithm must compare it to existing nodes across several layers to index it. As the number of vectors grows, thes... | [
0.010068204253911972,
-0.06025823950767517,
-0.06358505040407181,
-0.01786702685058117,
0.04213704541325569,
-0.035801906138658524,
0.06636466085910797,
0.035755906254053116,
0.060256440192461014,
-0.0005885990685783327,
0.031940560787916183,
0.043471354991197586,
0.05799899995326996,
-0.0... |
196a84ce-0bc3-54ab-9a11-1775fef3d074 | /course/essentials/day-0/qdrant-cloud/ | Qdrant Setup | Access the Web UI > What you can do in the Web UI > Inside a Collection | course | false | Qdrant Setup > Access the Web UI > What you can do in the Web UI > Inside a Collection
When you open a collection by clicking it's name,

you’ll get a detailed view with these tabs:

* **Points Tab**: ... | [
0.033185720443725586,
-0.04914351552724838,
-0.05416932702064514,
-0.01480309572070837,
0.05581062659621239,
-0.023727819323539734,
0.0456160232424736,
0.0326676182448864,
0.05833711102604866,
-0.040870215743780136,
0.0564822256565094,
0.03147371858358383,
0.03361237049102783,
-0.043193418... |
197f762d-f44e-568e-aade-04e0444e688f | /articles/filtered-vector-search-acorn/ | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN | Why Some Payload Fields Get No Extra Edges | article | false | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN > Why Some Payload Fields Get No Extra Edges
Skipping is deliberate: extra edges cost build time and memory, which is why the cap exists. A value under the cap can still be skipped when it sits below the `full_scan_threshold` floor or fails a sampled check... | [
0.030247295275330544,
-0.05810941755771637,
-0.04097156971693039,
-0.04033071547746658,
0.062012024223804474,
0.007966862991452217,
0.03724556043744087,
0.026455672457814217,
0.06479532271623611,
-0.036770522594451904,
0.04226962476968765,
0.03532806783914566,
0.03954445570707321,
-0.01616... |
199041a1-56df-50b6-94e3-cfd56f2376c8 | /documentation/tutorials-develop/hybrid-search-fastembed/ | Build a Hybrid Search API | Build the search API | documentation | true | Build a Hybrid Search API > Build the search API
Now that all the preparations are complete, let's start building a neural search class.
In order to process incoming requests, the hybrid search class will need 3 things: 1) models to convert the query into a vector, 2) the Qdrant client to perform search queries, 3) f... | [
0.0274103581905365,
-0.04578263312578201,
-0.051001936197280884,
-0.024880917742848396,
0.07463293522596359,
-0.04413248971104622,
0.09217031300067902,
0.07042492926120758,
0.07060025632381439,
-0.021999359130859375,
0.05140701308846474,
0.03152674436569214,
0.06222713366150856,
-0.0284622... |
19a7addd-5bb2-5a8f-89f7-abd2e7530816 | /documentation/frameworks/mem0/ | Mem0 | documentation | true | Mem0

[Mem0](https://mem0.ai) is a self-improving memory layer for LLM applications, enabling personalized AI experiences that save costs and delight users. Mem0 remembers user preferences, adapts to individual needs, and continuously improves over time, ide... | [
0.03227853775024414,
-0.050843317061662674,
-0.03310783579945564,
-0.01788545399904251,
0.05407408997416496,
-0.03119857981801033,
0.07281298190355301,
0.05468945577740669,
0.06702997535467148,
-0.02377723529934883,
0.01188037171959877,
-0.04504740238189697,
0.03954700380563736,
-0.0447304... | |
19a7ea9f-008c-5b68-8498-7a850b80e727 | /documentation/tutorials-search-engineering/pdf-retrieval-at-scale/ | Multivector Document Retrieval | Goal of This Tutorial | documentation | false | Multivector Document Retrieval > Goal of This Tutorial
In this tutorial, we will demonstrate a scalable approach to PDF retrieval using **Qdrant** and **ColPali** & **ColQwen2** VLLMs.
The presented approach is **highly recommended** to avoid the common pitfalls of long indexing times and slow retrieval speeds.
In th... | [
0.019597679376602173,
-0.05347396060824394,
-0.04366203770041466,
-0.039254672825336456,
0.09156421571969986,
-0.02639586105942726,
0.05973155051469803,
0.05071952939033508,
0.064006507396698,
0.005854030139744282,
0.005930191837251186,
0.001105634612031281,
0.04368898272514343,
-0.0306834... |
19b6fcad-30d7-5e84-89a6-beb18e2f32f6 | /documentation/frameworks/langchain/ | LangChain | Similarity search | documentation | true | LangChain > Similarity search
`QdrantVectorStore` supports 3 modes for similarity searches. They can be configured using the `retrieval_mode` parameter when setting up the class.
- Dense Vector Search(Default)
- Sparse Vector Search
- Hybrid Search
### Dense Vector Search
To search with only dense vectors,
- The `... | [
0.08233214914798737,
-0.04190141335129738,
-0.05804400146007538,
-0.018765253946185112,
0.06726390868425369,
-0.05681180581450462,
0.07194007933139801,
0.04946928843855858,
0.03739307075738907,
-0.03576493263244629,
0.044959474354982376,
0.023971019312739372,
0.03685862571001053,
-0.012910... |
19b73ed3-c398-56b0-bf61-dd6722070e35 | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Common Embedding Sources > 1. On-Premise, Optimized: FastEmbed by Qdrant | course | true | Points, Vectors and Payloads > Common Embedding Sources > 1. On-Premise, Optimized: FastEmbed by Qdrant
[FastEmbed](/documentation/fastembed/) is Qdrant's optimized embedding solution designed for on-premise, high-speed generation with minimal dependencies. It delivers low-latency, CPU-friendly embedding generation us... | [
0.03409109637141228,
-0.03253498673439026,
-0.026816928759217262,
-0.04861248657107353,
0.06914371997117996,
-0.027137748897075653,
0.07800589501857758,
0.0033803051337599754,
0.07825160026550293,
-0.041457172483205795,
0.02355221100151539,
0.013952525332570076,
0.03734494745731354,
-0.032... |
19d71f64-9187-5a52-a6d2-1c0def51176c | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > OnDemandReplicationType | documentation | false | API Reference > qdrant.io/v1 > Resource Types > OnDemandReplicationType
_Underlying type:_ _string_
OnDemandReplicationType specifies the on-demand replication restart mode.
_Validation:_
- Enum: [Off Auto On]
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description |
| --- | --- |
| `Off` | ... | [
0.036699626594781876,
-0.07704906165599823,
-0.04557936638593674,
-0.044692520052194595,
0.07410531491041183,
-0.04842725768685341,
0.04390142858028412,
0.07111828029155731,
0.05609123036265373,
-0.04266407713294029,
0.03648712858557701,
0.02595936879515648,
0.04918716475367546,
-0.0122132... |
19dc6b7e-c431-553d-9615-e6879f99f2f8 | /course/beginners/module-3/hybrid-search/ | Hybrid Search: Dense and Sparse | course | false | Hybrid Search: Dense and Sparse
Module 3
Hybrid search runs both retrievers in the same request and combines their ranked lists into one result set.
Run the same `Nike Pegasus 40` query through sparse alone and the picture inverts. The top three:
| Result | Sparse score |
|--------|--------------|
| Nike Pegasus 40... | [
0.06344988942146301,
-0.024156199768185616,
-0.05698905885219574,
-0.07563704252243042,
0.08241511136293411,
-0.045466113835573196,
0.03784826025366783,
0.015631699934601784,
0.05590388923883438,
-0.017564833164215088,
0.04952515289187431,
0.02098625712096691,
0.027282921597361565,
-0.0153... | |
19e65aaf-e842-5d38-aea7-3e29c10b108d | /documentation/capacity-planning/ | Capacity Planning | Calculating RAM and Disk Size > Dense Vectors > HNSW Vector Indexes | documentation | true | Capacity Planning > Calculating RAM and Disk Size > Dense Vectors > HNSW Vector Indexes
[The HNSW vector index](/documentation/manage-data/indexing/#vector-index) is the graph structure built over dense vectors that makes approximate nearest-neighbor search fast. Each dense vector defined in a collection's schema has ... | [
0.020788632333278656,
-0.038765303790569305,
-0.06978297978639603,
-0.03627205267548561,
0.042391110211610794,
-0.03352172672748566,
0.07819719612598419,
0.08260791748762131,
0.07207770645618439,
-0.03112100064754486,
0.014727816917002201,
0.03595823049545288,
0.039119984954595566,
0.01452... |
19f7889d-69f3-5195-aba5-e285c392ff9d | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | Why Vector Search Needs Indexing | course | false | HNSW Indexing Fundamentals > Why Vector Search Needs Indexing
### The Vector Search Challenge
You might wonder if Qdrant calculates the distance to every single vector in your collection for each query. This method, known as brute force search, technically works but with millions or billions of vectors this is too sl... | [
0.028135329484939575,
-0.03816378116607666,
-0.07796276360750198,
-0.03788091242313385,
0.05919678136706352,
-0.03737906739115715,
0.044027313590049744,
0.04986485093832016,
0.07198033481836319,
-0.010087825357913971,
0.01633884198963642,
0.04399501904845238,
0.04860450699925423,
-0.009787... |
1a355d7f-2515-5bb8-8cba-1e9b74801825 | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Payloads (Metadata) | course | false | Points, Vectors and Payloads > Payloads (Metadata)
While vectors capture the essence of data, payloads hold structured metadata for filtering and refinement. This combination enables you to combine semantic relevance from vectors with business logic from payloads.
Payloads can store textual data (descriptions, tags, ... | [
0.021936478093266487,
-0.043340183794498444,
-0.04457997903227806,
-0.059215523302555084,
0.004916802514344454,
-0.04796456918120384,
0.08460856974124908,
0.046319276094436646,
0.04187256470322609,
-0.03915407136082649,
0.032321665436029434,
0.02811327762901783,
0.06046678125858307,
-0.000... |
1a3caed8-984c-566d-9bf3-4e8e54c6df4a | /documentation/private-cloud/changelog/ | Changelog | 1.5.0 (2025-02-21) | documentation | false | Changelog > 1.5.0 (2025-02-21)
| Component | Version |
|------------------------|---------|
| qdrant-kubernetes-api | v1.12.0 |
| operator | 2.1.26 |
| qdrant-cluster-manager | v0.3.0 |
* Added support for P2P TLS configuration
* Faster node removal on scale down
* Various performance im... | [
0.038259901106357574,
-0.039952002465724945,
-0.051857396960258484,
-0.0020273777190595865,
0.028658824041485786,
-0.05089734494686127,
0.05380793288350105,
0.027534538879990578,
0.051396988332271576,
-0.029164908453822136,
0.036204468458890915,
0.009490090422332287,
0.044002633541822433,
... |
1a54077d-b51e-5846-a889-7cda6a248c2f | /documentation/snapshots/ | Snapshots | Restore snapshot > Snapshot priority | documentation | true | Snapshots > Restore snapshot > Snapshot priority
When recovering a snapshot to a non-empty node, there may be conflicts between the snapshot data and the existing data. The "priority" setting controls how Qdrant handles these conflicts. The priority setting is important because different priorities can give very
diffe... | [
0.029685616493225098,
-0.0204530768096447,
-0.026485217735171318,
-0.00733606331050396,
0.06309759616851807,
-0.02353520132601261,
0.05391547828912735,
-0.015456998720765114,
0.061051756143569946,
-0.05166809260845184,
0.03145475685596466,
0.04197659343481064,
0.03793871030211449,
-0.01169... |
1a6fd864-39de-528e-abd8-8f2030fa5461 | /course/beginners/module-6/ranking-and-reranking/ | Ranking: Score Boosting and Reranking | Score Boosting | course | false | Ranking: Score Boosting and Reranking > Score Boosting
Module 6
Two ways to change the order when the right documents are already coming back.
Similarity is not always the final ranking signal. A result may be relevant, but you may still want to prefer an exact title match, a nearby store, or a recent article. A [fo... | [
0.02662985399365425,
-0.018358545377850533,
-0.04021764174103737,
-0.06076398864388466,
0.061329443007707596,
-0.030713006854057312,
0.03376925364136696,
0.037283118814229965,
0.08533177524805069,
-0.033316418528556824,
0.027895372360944748,
0.0203871913254261,
0.05560784414410591,
0.02123... |
1a7ee2cf-65cf-5fc8-ae3d-c63b8314ef0c | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Implementation > Ingestion > Generating Embeddings | documentation | true | GraphRAG with Qdrant and Neo4j > Implementation > Ingestion > Generating Embeddings
Next, we define a function that generates embeddings for text using OpenAI's API.
```python
def openai_embeddings(text):
response = client.embeddings.create(
input=text,
model="text-embedding-3-small"
)
re... | [
0.04969099536538124,
-0.03337497264146805,
-0.024050960317254066,
-0.0663771703839302,
0.08932474255561829,
-0.04258871451020241,
0.04926715046167374,
0.10524926334619522,
0.02796677127480507,
-0.023600660264492035,
0.05435532331466675,
0.013747057877480984,
0.07256483286619186,
-0.0217732... |
1a827518-10cc-539e-ab18-00e821965089 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | Detailed Benchmarks | article | false | TurboQuant in Qdrant > Detailed Benchmarks
| Variant (compression) | arxiv-384 | arxiv-iXL | dbp-gem | dbp-3s | dbp-3l | dbp-oai | cohere | h&m | laion | ads-1M |
| --------------------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---------- | ---... | [
0.03769538179039955,
-0.0032322749029845,
-0.046003419905900955,
-0.0059199207462370396,
0.050273533910512924,
0.008236847817897797,
0.04443012550473213,
0.05500348284840584,
0.057876843959093094,
-0.01688895933330059,
0.07786611467599869,
0.00473115686327219,
0.04703948646783829,
-0.04756... |
1a8b0af9-c6cd-5759-83b6-e486cfa55a9a | /documentation/support/ | Support | Qdrant Cloud Support > Request Type | documentation | false | Support > Qdrant Cloud Support > Request Type
The form allows you to specify what your ticket is about:
- **Information** – Questions, analysis, or troubleshooting
- **Incidents** – Reporting bugs or disruptions in service
- **Billing** – Issues or questions related to charges, invoices, or payment
- **Features** – S... | [
0.02520749531686306,
-0.060565266758203506,
-0.044268880039453506,
-0.07182600349187851,
0.029814209789037704,
-0.03611993044614792,
0.039083223789930344,
0.05088743194937706,
0.0790974348783493,
-0.04347364231944084,
0.035112593322992325,
0.015155453234910965,
0.05152809992432594,
-0.0258... |
1a8fbfc6-8b44-50d2-8f67-91aa8f617d90 | /course/multi-vector-search/module-3/ | Module 3: Scalability and Optimization | course | false | Module 3: Scalability and Optimization
Module 3
Tackle the memory and performance challenges of production-scale multi-vector search.
---
## Today's path
1. Multi-Stage Retrieval with Universal Query API
2. Vector Quantization Techniques
3. Pooling Techniques
4. MUVERA
5. Evaluating Search Pipelines
6. Final Proje... | [
0.04718632996082306,
-0.045734573155641556,
-0.018826520070433617,
-0.04627349227666855,
0.05960160866379738,
-0.028092028573155403,
0.04417247325181961,
0.03559776023030281,
0.0839790627360344,
0.00882764533162117,
0.016748828813433647,
0.03963993862271309,
0.03374151140451431,
-0.0405471... | |
1a94db96-b728-5df2-bcdc-b8d3a1f09956 | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Compatibility > Should I create payload indexes before or after uploading? | documentation | false | Qdrant Fundamentals > Compatibility > Should I create payload indexes before or after uploading?
Create payload indexes before uploading to avoid index rebuilding. However, there are scenarios where defining idexes after uploading is okay. For example, you can configure a new filter logic after launch.
You should alw... | [
-0.0009125479264184833,
-0.006992192938923836,
-0.022503001615405083,
-0.030380990356206894,
0.06846669316291809,
-0.05352533608675003,
0.019990403205156326,
0.02816767804324627,
0.07812085002660751,
-0.037041421979665756,
0.05127640813589096,
0.03230101987719536,
0.0383378304541111,
-0.02... |
1a9d504b-f52a-5d69-a408-ea947a959450 | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Experiments > Results > Takeaways | article | false | Relevance Feedback in Qdrant > Experiments > Results > Takeaways
* Relevance feedback scoring is most effective when the feedback model (reasonably) disagrees with the retriever's ordering within the top-K (context limit). "Reasonably" meaning the feedback aligns with the user's actual notion of relevance.
* The retr... | [
0.016535526141524315,
-0.03721190243959427,
-0.021007191389799118,
-0.06082860007882118,
0.046938877552747726,
-0.03506729006767273,
0.06700686365365982,
0.008535213768482208,
0.06237214431166649,
-0.01993332989513874,
-0.00016394798876717687,
0.04854919761419296,
0.09672889113426208,
-0.0... |
1aa3fffb-92c0-5a71-b8c6-6adf0b20b244 | /documentation/cloud-account-setup/ | Account Setup | Account Settings | documentation | false | Account Setup > Account Settings
Open **Settings** for an account (from the **Accounts** page or the left navigation) to view and manage account details, including the **Account ID**, **Company**, **Account Owner**, and creation date.

### Editing Account... | [
0.012050739489495754,
-0.03219125047326088,
-0.06377770006656647,
-0.0009423544979654253,
0.01932290568947792,
-0.035041745752096176,
-0.031258318573236465,
0.06003651022911072,
0.045979127287864685,
-0.038981154561042786,
0.022133218124508858,
0.055723730474710464,
0.07261292636394501,
-0... |
1aa9c45c-e74b-5942-8635-5d03ce2f451f | /documentation/tutorials-build-essentials/video-anomaly-edge-part-2/ | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline | Edge-to-Cloud Escalation > Offline Resilience | documentation | true | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline > Edge-to-Cloud Escalation > Offline Resilience
 | documentation | false | Changelog > 1.8.0 (2025-08-08)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.17.2 |
| operator | 2.6.8 |
| qdrant-cluster-manager | v0.3.7 |
| qdrant-cluster-exporter | 1.7.1 |
* Add qdrant-cluster-exporter to provide OpenTelemetry/Prom... | [
0.03140188753604889,
-0.03727966919541359,
-0.051159512251615524,
-0.012301680631935596,
0.05740618705749512,
-0.045688580721616745,
0.05939135700464249,
0.07134908437728882,
0.05574638396501541,
-0.050908491015434265,
0.051161814481019974,
0.015852848067879677,
0.03821515291929245,
-0.058... |
1ab5843d-c54b-5921-b334-cb0d323950ba | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | Implementing Multi-Modal Search with FastEmbed and Qdrant > Indexing Visual Documents | course | true | How ColPali Models Work > Implementing Multi-Modal Search with FastEmbed and Qdrant > Indexing Visual Documents
Now let's index visual documents using Qdrant's **local inference** feature. This approach uses `models.Image()` to let Qdrant handle embedding generation automatically via FastEmbed:
```python
import uuid
... | [
0.04943595454096794,
-0.032423898577690125,
-0.04083934426307678,
-0.010368688963353634,
0.09790696203708649,
-0.027379827573895454,
0.06572170555591583,
0.027412552386522293,
0.039175380021333694,
-0.021532371640205383,
0.0370401069521904,
0.019339662045240402,
0.04067230224609375,
-0.047... |
1ac7f137-d7dd-5ea1-bbd2-6597db5a2789 | /documentation/ops-monitoring/monitoring/ | Monitoring & Telemetry | documentation | false | Monitoring & Telemetry
Qdrant exposes its metrics in [Prometheus](https://prometheus.io/docs/instrumenting/exposition_formats/#text-based-format)/[OpenMetrics](https://github.com/OpenObservability/OpenMetrics) format, so you can integrate them easily
with the compatible tools and monitor Qdrant with your own monitorin... | [
0.021001895889639854,
-0.04087783396244049,
-0.03258579596877098,
0.015614930540323257,
0.05098395794630051,
-0.015818824991583824,
0.09051307290792465,
0.0680048018693924,
0.06083863228559494,
-0.010904846712946892,
0.05835472792387009,
-0.028213556855916977,
0.060917600989341736,
-0.0151... | |
1ac99d60-79c9-536e-b97d-deb312fa1111 | /documentation/data-management/poma/ | POMA | documentation | false | POMA
| Time: 15 min | Level: Beginner/Intermediate | [Complete Notebook](https://colab.research.google.com/github/poma-ai/.github/blob/main/notebooks/qdrant/poma_meets_qdrant.ipynb) | [Notebook Source](https://github.com/poma-ai/.github/blob/main/notebooks/qdrant/poma_meets_qdrant.ipynb) |
| ------------ | -----------... | [
0.02598704770207405,
-0.04885438084602356,
-0.031850118190050125,
-0.06964840739965439,
0.09123212844133377,
-0.019717581570148468,
0.026322921738028526,
0.049211591482162476,
0.1144830584526062,
-0.010144555941224098,
0.04270437732338905,
-0.01261083222925663,
0.04354309290647507,
-0.0278... | |
1acb953d-07be-51db-930a-88631790e841 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Scalar Quantization > Theoretical Background > Distance Calculation | article | false | Scalar Quantization for Vector Search > Scalar Quantization > Theoretical Background > Distance Calculation
If we had to calculate all the terms to measure the distance, the performance could have
been even worse than without the conversion. But thanks for the fact we can precompute
the majority of the terms, things ... | [
0.04905971512198448,
-0.023699702695012093,
-0.004225932061672211,
-0.026320284232497215,
0.039320509880781174,
-0.007499547675251961,
0.07999294251203537,
0.05709216371178627,
0.12478005886077881,
-0.020203400403261185,
0.006619943771511316,
0.028424307703971863,
0.021237950772047043,
-0.... |
1af16066-ba9e-5f47-a420-c8dca17f84d2 | /course/essentials/day-0/building-simple-vector-search/ | Implementing a Basic Vector Search | course | false | Implementing a Basic Vector Search
Day 0
Follow along as we build your first collection, insert vectors, and run similarity searches. This guided tutorial walks you through each step. | [
0.03714387118816376,
-0.08629348129034042,
-0.044514674693346024,
-0.02049548551440239,
0.06780814379453659,
-0.025691157206892967,
0.028094995766878128,
0.011270563118159771,
0.05560198426246643,
-0.016417060047388077,
0.03139949589967728,
0.05634400621056557,
0.04273022711277008,
-0.0369... | |
1af4442d-0c12-57b5-bfe5-efaca41a9e75 | /documentation/cloud-user-profile/ | User Profile | Color Scheme | documentation | false | User Profile > Color Scheme
The Qdrant Cloud Console supports light and dark appearances. Under **Color Scheme** on the **Preferences** page you can choose:
* **Light Mode**
* **Dark Mode**
* **System Sync** — follow your operating system's appearance setting.
Your selection applies to the Console on your current de... | [
0.05024508759379387,
-0.024653522297739983,
-0.046964775770902634,
-0.05942592769861221,
0.06962135434150696,
-0.005367591977119446,
0.054203059524297714,
0.009490448981523514,
0.07929987460374832,
-0.0055200401693582535,
0.012710346840322018,
-0.032484859228134155,
0.04139915108680725,
-0... |
1b1d7dd2-f8ea-565b-acda-592535516925 | /documentation/embeddings/voyage/ | Voyage AI | Run voyage-4-nano Locally | documentation | true | Voyage AI > Run voyage-4-nano Locally
`voyage-4-nano` is an open-weight model on [Hugging Face](https://huggingface.co/voyageai/voyage-4-nano), released under the Apache 2.0 license, with about 340 million parameters. The Python SDK runs it locally through sentence-transformers, without an API key. It requires Python ... | [
0.058942195028066635,
-0.031773753464221954,
-0.046737682074308395,
-0.05128230154514313,
0.06855615228414536,
-0.044123630970716476,
0.05700818449258804,
0.03842710703611374,
0.015719272196292877,
-0.027405036613345146,
0.01114640012383461,
0.061763159930706024,
-0.001735964324325323,
-0.... |
1b2f99b8-8719-5451-9650-820522757ea4 | /documentation/frameworks/langchain/ | LangChain | documentation | true | LangChain
LangChain is a library that makes developing Large Language Model-based applications much easier. It unifies the interfaces
to different libraries, including major embedding providers and Qdrant. Using LangChain, you can focus on the business value instead of writing the boilerplate.
LangChain distributes t... | [
0.0170461256057024,
-0.016983874142169952,
-0.05202150717377663,
-0.01916779950261116,
0.05427434295415878,
-0.06701704114675522,
0.08908967673778534,
0.03533405810594559,
0.03633822500705719,
-0.011963739059865475,
0.010248427279293537,
-0.014360752888023853,
0.039576638489961624,
-0.0258... | |
1b3288d3-2420-507d-9577-3812506bbbe3 | /course/essentials/day-6/final-project/ | Final Project: Production-Ready Documentation Search Engine | Build Steps > Step 2: Collection Design | course | true | Final Project: Production-Ready Documentation Search Engine > Build Steps > Step 2: Collection Design
Create `docs_search` with three vectors (dense 384, sparse, ColBERT multivector with `m=0`).
*If you choose a 768-dim dense model, set `size=768` below.*
```python
collection_name = "docs_search"
client.create_colle... | [
0.03099449723958969,
-0.039096295833587646,
-0.05672029033303261,
-0.023725736886262894,
0.08033706247806549,
-0.033496011048555374,
0.04716118052601814,
0.07804916799068451,
0.07699765264987946,
-0.03172482177615166,
0.015375428833067417,
0.046098023653030396,
0.04935142397880554,
-0.0178... |
1b3542dd-bb80-569d-a94d-2f6f6d15d303 | /course/beginners/module-0/qdrant-cloud/ | Qdrant Setup | Access the Web UI > What You Can Do in the Web UI | course | false | Qdrant Setup > Access the Web UI > What You Can Do in the Web UI
Use the Web UI to manage collections, inspect data, and check how your searches perform.
#### Main Navigation
- **Console:** Run commands against Qdrant right in the browser. Great for testing and seeing responses without writing a program.
- **Collect... | [
0.036367494612932205,
-0.05761082470417023,
-0.06562887132167816,
-0.04617650434374809,
0.048215463757514954,
-0.019508877769112587,
0.0479033961892128,
0.012882858514785767,
0.058566782623529434,
-0.03376839682459831,
0.04066825285553932,
0.03305784985423088,
0.05678302049636841,
-0.04374... |
1b3a145c-84fc-5ca0-9f95-19d2a556ebdd | /articles/hyperbolic-embeddings-qdrant/ | Why Hyperbolic Embeddings Matter for Hierarchical Data | What Is a Manifold, and Where Do Our Vectors Live? | article | false | Why Hyperbolic Embeddings Matter for Hierarchical Data > What Is a Manifold, and Where Do Our Vectors Live?
A manifold is the space our embeddings live in. For embeddings, we care about the geometry we give that space. It determines how we measure distance, what the shortest path looks like, and how much room there is... | [
0.05009191855788231,
0.018226685002446175,
-0.04546469449996948,
-0.05895233526825905,
0.04964897781610489,
-0.04351731762290001,
0.08230030536651611,
0.06959737092256546,
0.08757582306861877,
-0.03893020376563072,
0.009203175082802773,
0.010830479674041271,
0.06174318492412567,
-0.0201125... |
1b427a86-7a1b-517a-b31b-4cbd128d1b81 | /documentation/embeddings/qdrant-cloud-inference/ | Qdrant Cloud Inference | documentation | false | Qdrant Cloud Inference
Clusters on [Qdrant Cloud](/documentation/cloud/) can generate embeddings on the server. Instead of a vector, you send the text or image together with a model name, and Qdrant embeds it before storing or searching. You don't run a separate embedding service. Two kinds of models are available:
-... | [
0.0471733994781971,
-0.029470769688487053,
-0.031578753143548965,
-0.04317503795027733,
0.07207696884870529,
-0.014943936839699745,
0.08422313630580902,
0.035091184079647064,
0.03968403488397598,
-0.01711144670844078,
0.04048146679997444,
-0.02131941355764866,
0.05436800420284271,
-0.03972... | |
1b429da3-b075-5114-9296-f932c33f21b5 | /documentation/hybrid-cloud/ | Hybrid Cloud | Hybrid Cloud Architecture | documentation | false | Hybrid Cloud > Hybrid Cloud Architecture
* The health status and resource usage (CPU, memory, disk and network) of the Qdrant databases and Qdrant control plane components.
* Metrics exposed by the Qdrant databases and Qdrant control plane components.
* Metrics about the configuration of the Kubernetes cluster, such a... | [
-0.0006322234985418618,
-0.00017678370932117105,
-0.04126356169581413,
-0.03891495615243912,
0.07176753878593445,
-0.03403610363602638,
0.052373453974723816,
0.025235701352357864,
0.0728582963347435,
-0.03499389812350273,
0.03007304109632969,
-0.007785152643918991,
0.07466243207454681,
-0.... |
1b43645c-4d70-5a26-af1e-a660d92db08e | /documentation/search/text-search/full-text-search/ | Full-Text Search | BM25 > Query a Text Field | documentation | true | Full-Text Search > BM25 > Query a Text Field
To run a BM25 query, use a `text` query and set `using` to the name of the indexed payload field. The following example searches for books with "time travel" in the title:
```python
from qdrant_client import QdrantClient, models
client.query_points(
collection_name="b... | [
0.03449464961886406,
-0.04396658390760422,
-0.02644863724708557,
-0.048392750322818756,
0.05829911679029465,
-0.044357478618621826,
0.030514512211084366,
0.04121897369623184,
0.022040804848074913,
0.004785086959600449,
0.07068942487239838,
0.03159044310450554,
0.03620319440960884,
-0.03190... |
1b6a854d-75ff-5203-bb40-ccf1fb797d9b | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | Different search modes > Exploring the results | documentation | true | Multimodal Food Search Demo > Different search modes > Exploring the results
The main feature of the demo is the ability to explore the space of the dishes. You can click on any of them to see more details, but first of all you can like or dislike it,
and the demo will update the search results accordingly.
, which we'll use to generate embeddings
locally:
```bash
pip install qdrant-client fastembed
```
We are going to use a local Docker-based instance of Qdrant. If you want to use a remote instance, please
adju... | [
0.01699366420507431,
-0.02473631128668785,
-0.018886635079979897,
-0.02998046576976776,
0.03734075278043747,
-0.06013289466500282,
0.06974487006664276,
0.0214742049574852,
0.04939638450741768,
0.009766507893800735,
0.03496377542614937,
0.027813903987407684,
0.0391109324991703,
-0.062341012... |
1bd096c4-a953-59fe-a058-c5902cbbd6a3 | /course/beginners/module-4/design-your-own-system/ | Design Your Own System | Try It Yourself: Design Your Own | course | false | Design Your Own System > Try It Yourself: Design Your Own
Use a new brief. Answer the five questions before opening the answers.
> A law firm wants to search 60,000 scanned contracts, each 20 to 80 pages long. Lawyers ask in plain language, such as "does this lease allow subletting", and every search must be scoped t... | [
0.018511295318603516,
-0.03444607928395271,
-0.08414525538682938,
-0.03137018531560898,
0.053132858127355576,
-0.03817479684948921,
0.05715646222233772,
0.0072050937451422215,
0.08332089334726334,
-0.01920888014137745,
0.035023629665374756,
0.033358946442604065,
0.08014291524887085,
-0.035... |
1be3065c-d1d7-567b-9518-57700d8be545 | /course/essentials/day-4/pitstop-project/ | Project: Quantization Performance Optimization | Optional: Go Further | course | true | Project: Quantization Performance Optimization > Optional: Go Further
### Dynamic Oversampling
Implement adaptive oversampling based on query characteristics:
```python
def adaptive_oversampling(query, base_factor=3.0):
"""Adjust oversampling based on query complexity"""
# Simple heuristic: longer queries ma... | [
0.04353214055299759,
-0.017466086894273758,
-0.009097106754779816,
-0.024249009788036346,
0.0562310628592968,
0.02649887278676033,
0.06384231895208359,
0.013558478094637394,
0.09797389805316925,
-0.03604873642325401,
0.024194223806262016,
0.014641708694398403,
0.05978913977742195,
-0.03541... |
1c087ff4-235b-5857-a4f6-4d8ee6817b57 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Results > Monolingual Retrieval | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Results > Monolingual Retrieval
| Direction | Retriever | MRR@10 | nDCG@10 | R@100 |
| --- | --- | --- | --- | --- |
| EN→EN | BM25 | 0.880 | 0.898 | 0.991 |
| EN→EN | miniCOIL v1 | **0.892** | **0.909** | 0.993 |
| EN→EN | miniCOIL EN-ES | 0.889 | ... | [
0.02855685167014599,
-0.035394035279750824,
-0.01922742649912834,
-0.03840458020567894,
0.06733132153749466,
-0.060698848217725754,
0.06012043356895447,
0.05846904218196869,
0.07380445301532745,
-0.03237096965312958,
0.025718748569488525,
0.024952050298452377,
0.06356818974018097,
-0.03684... |
1c089f87-b075-5425-9e5d-7d252a8651bc | /documentation/quickstart/ | Local Quickstart | Add vectors | documentation | true | Local Quickstart > Add vectors
Let's now add a few vectors with a payload. Payloads are other data you want to associate with the vector:
```python
from qdrant_client.models import PointStruct
operation_info = client.upsert(
collection_name="test_collection",
wait=True,
points=[
PointStruct(id=1,... | [
0.008755693212151527,
-0.02784906141459942,
-0.040862470865249634,
-0.05812923237681389,
0.07458066195249557,
-0.015661099925637245,
0.010658452287316322,
0.028272727504372597,
0.07422589510679245,
-0.033768754452466965,
0.0510152243077755,
0.020276352763175964,
0.03741496056318283,
-0.017... |
1c0a9896-b772-5c60-82ee-5222516bcd65 | /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
1. **Encryption**: This ensures that sensitive data is scrambled as it travels between the application and the vector database. This safeguards against Man-in-the-Middle ([MitM](https://en.wikipedia.org/wiki/Man-in-the-... | [
0.012834559194743633,
-0.03754229098558426,
-0.058254823088645935,
-0.04530974105000496,
0.046058472245931625,
-0.030713168904185295,
0.05186320096254349,
0.02978016622364521,
0.07765331119298935,
0.004991817753762007,
0.008660945110023022,
0.0365094430744648,
0.09012972563505173,
-0.02762... |
1c184e92-fe6e-5755-a1c4-9970f17f7bb9 | /documentation/edge/edge-quickstart/ | Quickstart | Optimize the Edge Shard | documentation | true | Quickstart > Optimize the Edge Shard
Optimization is the process of removing data marked for deletion, merging segments, and creating indexes. Qdrant Edge does not have a background optimizer. Instead, an application can call the `optimize` method to synchronously run optimization at a suitable time, such as during lo... | [
0.002910088514909148,
-0.045980148017406464,
-0.06077203527092934,
-0.04660024121403694,
0.07861504703760147,
-0.02584725059568882,
0.07734952867031097,
0.019577207043766975,
0.07458821684122086,
-0.03390675410628319,
0.055126216262578964,
0.017443597316741943,
0.019780024886131287,
-0.055... |
1c4316f6-cebd-5763-b27c-501134a4fc03 | /documentation/cloud-quickstart/ | Cloud Quickstart | 6. Search the Menu Items | documentation | true | Cloud Quickstart > 6. Search the Menu Items
Now we can search the menu item dataset! We'll use the same `sentence-transformers/all-MiniLM-L6-v2` model in Cloud Inference to embed our query text, then find the best dishes matching that embedding.
```python
# generate query embedding
query_text = "vegetarian dishes"
#... | [
0.05730101466178894,
-0.01672794669866562,
-0.046954572200775146,
-0.02950804866850376,
0.08041740953922272,
-0.018879372626543045,
0.07520421594381332,
0.023472124710679054,
0.05019715800881386,
0.0047065154649317265,
0.016852909699082375,
0.031697291880846024,
0.05014655366539955,
-0.019... |
1c4be88e-1816-541d-a4b0-50cf5786e7ad | /documentation/examples/rag-contract-management-stackit-cohere/ | Region-Specific Contract Management System | Implementation > Qdrant collection | documentation | true | Region-Specific Contract Management System > Implementation > Qdrant collection
Cohere Embed 5 lets you choose the size of the vectors with the `output_dimension` parameter (`256`, `512`, `768`, `1024`,
`1536`, or `2048`). This tutorial asks for `1024` dimensions, which keeps the vectors compact. Qdrant can store larg... | [
0.040907490998506546,
-0.03744722157716751,
-0.037070851773023605,
-0.030196473002433777,
0.05563054606318474,
-0.06529971957206726,
0.06962983310222626,
0.06001107394695282,
0.10171506553888321,
-0.04097404330968857,
0.018258636817336082,
0.008886306546628475,
0.053360193967819214,
-0.050... |
1c5f51a6-b049-5c77-94d7-96d6bf1b5292 | /course/essentials/day-7/jina/ | Integrating with Jina AI | Jina AI Multimodal Embeddings > Performance Optimization | course | false | Integrating with Jina AI > Jina AI Multimodal Embeddings > Performance Optimization
**Retrieval Enhancement**:
- **Multi-Vector Benefits**: Improved accuracy for complex visual documents
- **Cross-Modal Search**: Enhanced user experience with flexible query types
- **Scalable Architecture**: Efficient processing of la... | [
0.01013131532818079,
-0.04733025282621384,
-0.060520660132169724,
-0.025598403066396713,
0.08096220344305038,
-0.010206243954598904,
0.04847400635480881,
0.019902428612113,
0.05370411276817322,
-0.01887723058462143,
0.03610998019576073,
-0.004348400980234146,
0.03590517118573189,
-0.038419... |
1c6a9d08-051a-5892-b758-5d1813cee3f9 | /documentation/installation/ | Installation | CPU and memory | documentation | false | Installation > CPU and memory
The following sections describe the requirements for deploying Qdrant.
The preferred size of your CPU and RAM depends on:
- Number of vectors
- Vector dimensions
- [Payloads](/documentation/manage-data/payload/) and their indexes
- Storage
- Replication
- How you configure quantization
... | [
0.006113477982580662,
-0.06187676638364792,
-0.0422164723277092,
-0.023653320968151093,
0.064546138048172,
-0.055570438504219055,
0.051348358392715454,
0.046290043741464615,
0.09691905975341797,
-0.03918176889419556,
-0.0096806725487113,
-0.006959613412618637,
0.012014578096568584,
-0.0581... |
1c8f7b30-3e59-52e0-94f6-2c5242540134 | /documentation/tutorials-search-engineering/turbo4-multivector-search/ | Compressed Multivector Search | Query | documentation | true | Compressed Multivector Search > Query
[Prefetch](/documentation/search/hybrid-queries/) candidates using the BM25 `title` vector, then rescore them with the ColBERT `description` vector through late interaction. Give the prefetch a `limit` well above the final `limit`, so the rescore has a real candidate pool to work ... | [
0.015520528890192509,
-0.06633955240249634,
-0.0207534059882164,
-0.025002403184771538,
0.0728890523314476,
-0.033022355288267136,
0.04412244260311127,
0.04347634315490723,
0.044300224632024765,
0.021271120756864548,
0.04404594004154205,
0.019230380654335022,
0.054603949189186096,
-0.02683... |
1cac54be-eef1-5bdb-b947-f36cc470893c | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Implementation > Prerequisites > Initializing Neo4j and Qdrant Clients | documentation | true | GraphRAG with Qdrant and Neo4j > Implementation > Prerequisites > Initializing Neo4j and Qdrant Clients
Now, we initialize the Neo4j and Qdrant clients using the credentials.
Show code
```python
# Initialize Neo4j driver
neo4j_driver = GraphDatabase.driver(neo4j_uri, auth=(neo4j_username, neo4j_password))
# Initial... | [
0.03152703866362572,
-0.06595964729785919,
-0.030936764553189278,
-0.020978137850761414,
0.07060509920120239,
-0.04434260353446007,
0.06007533147931099,
0.07496893405914307,
0.02923150546848774,
-0.03179403021931648,
0.03934861719608307,
0.033658575266599655,
0.04622408747673035,
-0.031300... |
1cba0202-c5a6-58ce-97e0-a67a640b3668 | /documentation/migrate-to-qdrant/from-turbopuffer/ | From Turbopuffer | Run the Migration | documentation | true | From Turbopuffer > Run the Migration
```bash
docker run --net=host --rm -it registry.cloud.qdrant.io/library/qdrant-migration turbopuffer \
--turbopuffer.namespace 'your-namespace' \
--turbopuffer.api-key 'your-turbopuffer-api-key' \
--turbopuffer.region 'gcp-us-central1' \
--qdrant.url 'https://your-i... | [
0.037959810346364975,
-0.06057364121079445,
-0.035327740013599396,
-0.033820733428001404,
0.09652505069971085,
-0.009882400743663311,
0.07227611541748047,
0.05123263970017433,
0.029380716383457184,
-0.029283884912729263,
0.04643292352557182,
0.013607801869511604,
0.033713214099407196,
-0.0... |
1cf747a6-3c47-5665-b264-997c501108b1 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search > BASE: Prioritizing Availability | article | false | Why Vector Search Needs a Dedicated Database > Vector Search > BASE: Prioritizing Availability
On the other hand, the BASE model favors high availability and partition tolerance. BASE systems distribute data and workload across multiple nodes, enabling them to respond to read and write requests immediately. They opera... | [
-0.041950300335884094,
-0.05726758390665054,
-0.04459464177489281,
-0.05235850811004639,
0.050204310566186905,
-0.0441250242292881,
0.06504137068986893,
-0.0033146983478218317,
0.06654681265354156,
0.03160736337304115,
0.014407865703105927,
0.03629404306411743,
0.06027582660317421,
-0.0282... |
1cfd3627-10d0-58f7-b9de-ae6fdcb5bace | /documentation/examples/hybrid-search-llamaindex-jinaai/ | Chat With Product PDF Manuals Using Hybrid Search | Prerequisites | documentation | true | Chat With Product PDF Manuals Using Hybrid Search > Prerequisites
### Deploying Qdrant Hybrid Cloud on DigitalOcean
[DigitalOcean Kubernetes (DOKS)](https://www.digitalocean.com/products/kubernetes) is a managed Kubernetes service. It runs the control plane for you, works with standard Kubernetes tools, and integrate... | [
0.0334392786026001,
-0.055984560400247574,
-0.051467642188072205,
-0.05924582853913307,
0.07157117128372192,
-0.03791838511824608,
0.0772973820567131,
0.07389415055513382,
0.08172031491994858,
-0.02867286279797554,
0.0014514366630464792,
0.0036030616611242294,
0.011245454661548138,
-0.0297... |
1d03c394-9c02-5c75-8f19-2eb97e22f6d4 | /documentation/fastembed/fastembed-rerankers/ | Reranking with FastEmbed | Setup | documentation | true | Reranking with FastEmbed > Setup
Install `qdrant-client` with `fastembed`.
```python
pip install "qdrant-client[fastembed]>=1.14.1"
```
Import cross-encoders and text embeddings for the first-stage retrieval.
```python
from fastembed import TextEmbedding
from fastembed.rerank.cross_encoder import TextCrossEncoder
`... | [
0.06406313925981522,
-0.05871941149234772,
-0.013882367871701717,
-0.05321156978607178,
0.06567070633172989,
-0.04813290387392044,
0.05877933278679848,
0.036845721304416656,
0.03364874795079231,
-0.0003925574419554323,
0.04221970587968826,
0.0029173719231039286,
0.09213307499885559,
-0.066... |
1d24cdb0-eb6d-534a-8714-ed6fa460fecd | /documentation/tutorials-develop/code-search/ | Semantic Search for Code | Summary | documentation | false | Semantic Search for Code > Summary
This tutorial demonstrates how to use Qdrant to navigate a codebase. For an
end-to-end implementation, review the [code search
notebook](https://colab.research.google.com/github/qdrant/examples/blob/master/code-search/code-search.ipynb) and the
[code-search-demo](https://github.com... | [
0.05015429109334946,
-0.06226719915866852,
-0.056663189083337784,
-0.04290658235549927,
0.026080751791596413,
-0.03703103959560394,
0.07873094826936722,
0.012975103221833706,
0.050294775515794754,
-0.005772490054368973,
0.052896060049533844,
0.03143853321671486,
0.06956391781568527,
-0.036... |
1d24ef3f-ca7d-5b58-8674-6677db0682f2 | /documentation/tutorials-build-essentials/agentic-rag-camelai-discord/ | Discord RAG Bot | Step 2: Configure the Connections | documentation | true | Discord RAG Bot > Step 2: Configure the Connections
Create a `.env` file beside your script:
```ini
OPENAI_API_KEY=your-openai-api-key
QDRANT_CLOUD_URL=https://your-cluster.cloud.qdrant.io:6333
QDRANT_CLOUD_API_KEY=your-qdrant-api-key
QDRANT_COLLECTION=qdrant-discord-docs-v1
DISCORD_BOT_TOKEN=your-discord-bot-token
`... | [
0.03749719634652138,
-0.05712215602397919,
-0.033321116119623184,
0.013043226674199104,
0.05603858828544617,
-0.04989628121256828,
0.04801023378968239,
0.07414400577545166,
0.036385677754879,
-0.031599968671798706,
0.023288840427994728,
-0.03384687379002571,
0.061437517404556274,
-0.030741... |
1d3c1c57-bc0e-555b-8720-371829e45b1b | /documentation/tutorials-build-essentials/video-anomaly-edge-part-2/ | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline | Edge Triage: Why Imperfect Is the Point | documentation | false | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline > Edge Triage: Why Imperfect Is the Point
Processing every frame in the cloud is not only difficult (limited bandwidth, high latency) but also costly. Let's prove it with some simple math.
How much would it cost to process 24 hours of continuous surveillance thro... | [
0.03388670086860657,
-0.027466412633657455,
-0.08569452911615372,
-0.044648487120866776,
0.058137375861406326,
-0.009071798995137215,
0.02795311063528061,
0.0052871438674628735,
0.09206542372703552,
-0.07288706302642822,
0.018751535564661026,
-0.009301324374973774,
0.051813144236803055,
-0... |
1d6d4adb-d08f-558e-a35f-3065a50dd844 | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Enabling Distributed Mode in Qdrant Cloud | documentation | false | Distributed Deployment > Enabling Distributed Mode in Qdrant Cloud
For best results, first ensure your cluster is running Qdrant v1.7.4 or higher. Older versions of Qdrant do support distributed mode, but improvements in v1.7.4 make distributed clusters more resilient during outages.
To enable distributed mode, in th... | [
0.06606771051883698,
-0.031150583177804947,
-0.04241851717233658,
-0.051167700439691544,
0.08848529309034348,
-0.043599557131528854,
0.05872887000441551,
0.039700791239738464,
0.07310330122709274,
-0.011479591950774193,
0.035277608782052994,
0.008790837600827217,
0.041101571172475815,
-0.0... |
1d6e3b23-fa57-5cb3-bb0b-32145743ea81 | /course/multi-vector-search/ | Multi-Vector Search Course | Syllabus | course | false | Multi-Vector Search Course > Syllabus
- title: "Module 0: Setting Up Dependencies"
content: |
- Qdrant Setup
- Installing Dependencies
→ Start Module 0
- title: "Module 1: Multi-Vector Representations for Textual Data"
content: |
- Late Interaction Basics
- MaxSim Distance Metric
- Use Cases ... | [
0.05744382366538048,
-0.05732571333646774,
-0.020738549530506134,
-0.022575868293642998,
0.07071495801210403,
-0.03030080534517765,
0.0653388649225235,
0.05172246694564819,
0.047605838626623154,
-0.012131622061133385,
0.044377461075782776,
0.0600956529378891,
0.027225306257605553,
-0.05280... |
1d815ad6-2e3b-576b-9f8e-b7adf830ae19 | /course/essentials/day-0/building-simple-vector-search/ | Implementing a Basic Vector Search | Step 8: Run Your First Similarity Search | course | true | Implementing a Basic Vector Search > Step 8: Run Your First Similarity Search
Find the most similar vector to a given query using Qdrant's search capabilities:
**How Similarity Search Works:**
- Qdrant searches the collection to find the vectors that are closest to your query vector.
- The results are ranked by their... | [
0.06487198173999786,
-0.07387717068195343,
-0.03921133279800415,
-0.004065866582095623,
0.06874152272939682,
-0.03430171683430672,
0.06123809143900871,
0.012195291928946972,
0.06417160481214523,
-0.03498878329992294,
0.04863693192601204,
0.02536378800868988,
0.04962566867470741,
-0.0131730... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.