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 |
|---|---|---|---|---|---|---|---|
0f1dc02f-90b6-53b6-ab44-f2fef34320cc | /documentation/scaling/consistency-guarantees/ | Consistency Guarantees | documentation | false | Consistency Guarantees
- `write_consistency_factor` - defines the number of replicas that must acknowledge a write operation before responding to the client. Increasing this value will make write operations tolerant to network partitions in the cluster, but will require a higher number of replicas to be active to perf... | [
0.004040752537548542,
-0.07688483595848083,
-0.08099158108234406,
-0.005583259277045727,
0.07430765777826309,
-0.02183762565255165,
0.07441232353448868,
0.031219342723488808,
0.04078884795308113,
-0.008768565021455288,
0.03064108081161976,
0.03082919307053089,
0.02481042593717575,
-0.01221... | |
0f34d412-ab4d-568b-95b4-dd3512247ecc | /articles/bm42/ | BM42: Attention-Based Sparse Embeddings for Hybrid Search | article | false | BM42: Attention-Based Sparse Embeddings for Hybrid Search
Please note that the benchmark section of this article was updated after the publication due to a mistake in the evaluation script.
BM42 does not outperform BM25 implementation of other vendors.
Please consider BM42 as an experimental approach, which requires f... | [
0.031115135177969933,
-0.022323377430438995,
-0.029082966968417168,
-0.04636160656809807,
0.05952439829707146,
-0.08553708344697952,
0.05518538877367973,
0.06308992207050323,
0.05043742060661316,
-0.005840126890689135,
0.02928079105913639,
0.04706719517707825,
0.043583158403635025,
-0.0336... | |
0f5ad6a5-16af-5b4b-8c4b-2f818cff6ee8 | /documentation/private-cloud/qdrant-cluster-management/ | Managing a Cluster | Authentication and Authorization | documentation | true | Managing a Cluster > Authentication and Authorization
By default, clusters in Hybrid Cloud are only exposed through a Kubernetes ClusterIP Service inside of the Kubernetes network and not accessible to the outside, and no API key is configured. If you choose to expose the database internally or externally, you must co... | [
0.028700947761535645,
0.019029319286346436,
-0.06196800246834755,
-0.06281142681837082,
0.05804533138871193,
-0.0655953660607338,
0.05427345633506775,
0.0741138681769371,
0.030025269836187363,
-0.04681958258152008,
0.044572003185749054,
0.019926808774471283,
0.09420107305049896,
-0.0239893... |
0f662e06-26d7-5b7e-ad1a-9e1f50b9097c | /articles/search-feedback-loop/ | Relevance Feedback in Information Retrieval | Has the Problem Already Been Solved? | article | false | Relevance Feedback in Information Retrieval > Has the Problem Already Been Solved?
Digging through research materials, we expected anything else but to discover that the first relevance feedback study dates back [*sixty years*](https://sigir.org/files/museum/pub-08/XXIII-1.pdf).
In the midst of the neural search bubbl... | [
0.05587463825941086,
-0.02706778794527054,
-0.0467853806912899,
-0.03752421215176582,
0.05421680957078934,
-0.06548283994197845,
0.026865478605031967,
0.023713957518339157,
0.07542801648378372,
-0.015258373692631721,
0.030385397374629974,
0.03236773610115051,
0.05397101119160652,
-0.031408... |
0f6a13ab-fe14-5d09-9b0e-a657da9dd21a | /documentation/search/filtering/ | Filtering | Filtering Conditions > Nested Key > Nested Object Filter | documentation | true | Filtering > Filtering Conditions > Nested Key > Nested Object Filter
To speed up nested filters, create [per-element indexes](/documentation/manage-data/indexing/#per-element-index-for-arrays-of-objects) on the fields of the array. Qdrant then answers a nested filter from the indexes alone if every condition in it is ... | [
0.0409822054207325,
-0.035809461027383804,
-0.05854130908846855,
-0.02749866060912609,
0.04129405319690704,
-0.020881976932287216,
0.06683498620986938,
0.02553486078977585,
0.08040700107812881,
-0.03174227848649025,
0.03911830857396126,
0.04977770522236824,
0.07981850206851959,
-0.01106432... |
0f6e5492-f4ba-56f4-be7a-9b947363b333 | /documentation/private-cloud/changelog/ | Changelog | 1.4.0 (2025-01-23) | documentation | false | Changelog > 1.4.0 (2025-01-23)
| Component | Version |
|------------------------|---------|
| qdrant-kubernetes-api | v1.8.0 |
| operator | 2.1.26 |
| qdrant-cluster-manager | v0.3.0 |
* Support deleting peers on horizontal scale down, even if they are already offline
* Support removing... | [
0.03609142452478409,
-0.013525443151593208,
-0.053970035165548325,
-0.006847910117357969,
0.0478527806699276,
-0.029995324090123177,
0.05590583384037018,
0.05261310562491417,
0.055968549102544785,
-0.047789573669433594,
0.031554389744997025,
0.013934381306171417,
0.04361135885119438,
-0.05... |
0f82c931-d097-5cb1-99b7-d22b69b9c706 | /course/essentials/day-1/chunking-strategies/ | Text Chunking Strategies | course | false | Text Chunking Strategies
Day 1
So far we've talked about points - what they're made of, and how Qdrant compares them for approximate nearest neighbor search using distance metrics like cosine similarity, dot product, or Euclidean distance.
But none of this matters until we give Qdrant something meaningful to compare... | [
0.057340074330568314,
-0.05759262666106224,
-0.04365361109375954,
-0.04571573808789253,
0.04625380411744118,
-0.07313386350870132,
0.053726550191640854,
0.004038860555738211,
0.0850415900349617,
-0.022679444402456284,
0.059938207268714905,
-0.005362191237509251,
0.06648766249418259,
-0.020... | |
0f8574bf-9861-54ed-90bf-a6638d86409e | /course/beginners/module-1/distance-metrics/ | Comparing Meaning: Distance Metrics | Distance Metric Comparison | course | false | Comparing Meaning: Distance Metrics > Distance Metric Comparison
| Metric | Common use | Notes |
|--------|----------|-------|
| Cosine | Text similarity, NLP (Natural Language Processing) models | Compares vector direction and ignores vector length. A common default for text embeddings. |
| Dot product | Vectors alre... | [
0.06126226857304573,
-0.04558103159070015,
-0.05468129366636276,
-0.0514812096953392,
0.06036612018942833,
-0.01695377752184868,
0.07995349913835526,
0.05452729016542435,
0.1005973145365715,
-0.01823330670595169,
0.0549686960875988,
-0.0037054193671792746,
0.028433073312044144,
-0.00954404... |
0f8fb764-f38d-5394-8f0b-2b33b55aa2c7 | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Understanding Reranking > Working | documentation | false | Reranking for Better Search > Understanding Reranking > Working
1. **Cross Encoder Models**: These boost reranking by using a classification system to evaluate pairs of data—like sentences or documents. They output a relevance score showing how closely the document matches your query. The catch? Cross-encoders need bo... | [
0.04228471964597702,
-0.0536235049366951,
-0.07096732407808304,
-0.060439664870500565,
0.035233110189437866,
-0.016597727313637733,
0.0455816313624382,
-0.01194177195429802,
0.06687983870506287,
-0.015079907141625881,
0.012065719813108444,
0.012529010884463787,
0.07157402485609055,
-0.0139... |
0fc17497-a1bd-51c6-b7a6-218466b1e6d4 | /documentation/snapshots/ | Snapshots | documentation | false | Snapshots
*Available as of v0.8.4*
Snapshots are `tar` archive files that contain data and configuration of a specific collection on a specific node at a specific time. In a distributed setup, when you have multiple nodes in your cluster, you must create snapshots for each node separately when dealing with a single c... | [
-0.002137630945071578,
-0.03825370594859123,
-0.04683791473507881,
-0.058593932539224625,
0.026496337726712227,
-0.01734367571771145,
0.07197815179824829,
0.044138871133327484,
0.08074871450662613,
-0.06286567449569702,
0.03475907817482948,
0.027082813903689384,
0.034306950867176056,
-0.01... | |
0fc857e6-ccac-584a-8380-1c946647f7fa | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Implementing Vector Search with Reranking > Implementation > Documents to Embeddings | documentation | true | Reranking for Better Search > Implementing Vector Search with Reranking > Implementation > Documents to Embeddings
Let’s set up some example data. Here’s a query and a few documents for demonstration. The last two documents use “feature scaling” outside machine learning, to show what reranking catches:
```python
quer... | [
0.06084635108709335,
-0.0449528768658638,
-0.04510660842061043,
-0.05449791997671127,
0.08191659301519394,
-0.06826292723417282,
0.051591623574495316,
0.07369327545166016,
0.07432340085506439,
-0.025509655475616455,
0.0018623279174789786,
0.024359403178095818,
0.043449223041534424,
-0.0388... |
0fd34d37-4e4e-514f-ac44-0be9896e4de8 | /documentation/private-cloud/private-cloud-setup/ | Setup Private Cloud | Requirements | documentation | false | Setup Private Cloud > Requirements
- **Kubernetes cluster:** To install Qdrant Private Cloud, you need a [standard compliant](https://www.cncf.io/training/certification/software-conformance/) Kubernetes cluster. You can run this cluster in any cloud, on-premise or edge environment, with distributions that range from A... | [
0.014365224167704582,
-0.04497029259800911,
-0.0439506433904171,
-0.041918303817510605,
0.038469649851322174,
-0.03997120261192322,
0.027146434411406517,
0.033184655010700226,
0.05259288102388382,
-0.05667503550648689,
0.012785675004124641,
0.006585333030670881,
0.047973476350307465,
-0.05... |
0fe9c00f-a13b-516f-9f8e-b71f0ab8c968 | /documentation/frameworks/deepeval/ | DeepEval | Using Qdrant with DeepEval | documentation | true | DeepEval > Using Qdrant with DeepEval
Install the client libraries.
```bash
$ pip install deepeval qdrant-client
$ deepeval login
```
You can use Qdrant to power your RAG system by retrieving relevant documents for a query, feeding them into your prompt, and evaluating the generated output using DeepEval.
```pytho... | [
0.04283441603183746,
-0.06963487714529037,
-0.014378298074007034,
-0.07450710982084274,
0.05630974471569061,
-0.05573897063732147,
0.09031893312931061,
0.06872375309467316,
0.04135539382696152,
-0.06378645449876785,
0.009964220225811005,
0.008906257338821888,
0.07882017642259598,
-0.022852... |
100b3c4e-d793-5b23-b194-88615c837906 | /course/beginners/module-5/ingestion-pipeline/ | Ingestion Pipeline | course | true | Ingestion Pipeline
Module 5
The daily job collects signals, embeds each modality, and upserts them. A risk scoring step assigns an initial `risk_score`, which analysts later filter on.
Risk scoring is a keyword baseline, deliberately simple, and the first thing to replace once you have labeled signals of your own:
... | [
0.06453512609004974,
-0.007139103952795267,
-0.06751199066638947,
-0.03374714031815529,
0.0639612153172493,
-0.01208455115556717,
0.054571717977523804,
0.04493458941578865,
0.057641319930553436,
-0.014355883933603764,
0.022209949791431427,
0.01983731798827648,
0.046333495527505875,
-0.0530... | |
1013bf51-67b2-54cb-adcf-e75f297afa15 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Weighting Tokens | course | false | Demo: Keyword Search with Sparse Vectors > Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Weighting Tokens
The tokenized text, now represented as token indices, is passed through the SPLADE model.
SPLADE **expands** the input by adding contextually relevant tokens and simultaneously assigns e... | [
0.07845113426446915,
-0.02854393795132637,
-0.03535735607147217,
-0.0619160421192646,
0.0879134088754654,
-0.04136761277914047,
0.031227996572852135,
0.0335988812148571,
0.05229615792632103,
-0.017622387036681175,
0.0278212558478117,
0.01937749981880188,
0.020599577575922012,
0.00599297648... |
10190ee9-e6c0-544e-a33f-e07b6fe0fcf4 | /course/multi-vector-search/module-2/visual-interpretability/ | Visual Interpretability of ColPali | A Note on Newer Architectures | course | false | Visual Interpretability of ColPali > A Note on Newer Architectures
The interpretability techniques we've covered work directly with ColPali because of its simple spatial mapping: 448×448 pixels -> 32×32 patches -> 1024 embeddings. Each patch index maps directly to a spatial location.
However, **newer architectures us... | [
0.03194253519177437,
-0.034958161413669586,
-0.06938638538122177,
-0.03413137048482895,
0.08683373779058456,
-0.020053081214427948,
0.03362132981419563,
0.04850194975733757,
0.054115068167448044,
-0.012622796930372715,
0.04879540950059891,
-0.012259608134627342,
0.044703878462314606,
-0.02... |
1029a398-41c6-54e4-83c1-bc4402174010 | /articles/dataset-quality/ | Detecting Dataset Errors with Similarity Search | article | false | Detecting Dataset Errors with Similarity Search
Nowadays, people create a huge number of applications of various types and solve problems in different areas.
Despite such diversity, they have something in common - they need to process data.
Real-world data is a living structure, it grows day by day, changes a lot and ... | [
0.057921797037124634,
-0.016178658232092857,
-0.06590922176837921,
-0.009735677391290665,
0.04873855039477348,
-0.03194510564208031,
0.04939759150147438,
0.046283189207315445,
0.03536691144108772,
-0.030355190858244896,
0.02485685795545578,
0.053745005279779434,
0.07557062804698944,
-0.022... | |
10907562-7386-5a24-a6c8-d408b8168449 | /documentation/embeddings/jina-embeddings/ | Jina AI | Reduce Vector Size | documentation | true | Jina AI > Reduce Vector Size
v5 models use Matryoshka Representation Learning, so the `dimensions` parameter shortens the vector with little loss in quality, down to 32 dimensions. Set the collection's `size` to the same value, and pass the same `dimensions` when you embed queries:
```python
reduced = jina_embed(mode... | [
0.039597123861312866,
-0.01577562652528286,
-0.023285605013370514,
-0.052889373153448105,
0.0481996089220047,
-0.007381772622466087,
0.035273488610982895,
0.019427679479122162,
0.08928232640028,
-0.011383140459656715,
0.060469381511211395,
0.020199134945869446,
0.06126901134848595,
-0.0268... |
10a3c262-e93a-5618-9b76-031a86376d03 | /documentation/embeddings/voyage/ | Voyage AI | Next Steps | documentation | false | Voyage AI > Next Steps
- Read the [Voyage AI embeddings documentation](https://docs.voyageai.com/docs/embeddings) for model details.
- [Filter search results](/documentation/search/filtering/) by payload fields.
- [Combine Voyage AI vectors with sparse vectors](/documentation/search/hybrid-queries/) for hybrid search.... | [
0.04601230472326279,
-0.04282703250646591,
-0.03639913722872734,
-0.052359942346811295,
0.0708351656794548,
-0.00942456815391779,
0.04877907410264015,
0.004295267630368471,
0.03599851578474045,
-0.03682127967476845,
0.01219245046377182,
0.026246899738907814,
0.04939425364136696,
0.01951962... |
10c94d02-7538-5770-8eb2-eca34dc8a079 | /documentation/common-errors/ | Troubleshooting | Incompatible file system | documentation | true | Troubleshooting > Incompatible file system
Qdrant have a [set of requirements](/documentation/installation/#storage) for persistent file storage.
The most important requirement is that file system **must** be [POSIX-compatible](https://www.quobyte.com/storage-explained/posix-filesystem/).
Starting from v1.15.0 Qdrant... | [
0.041609518229961395,
-0.0574849434196949,
-0.02193739265203476,
-0.054770346730947495,
0.0607900395989418,
-0.06460027396678925,
0.062120843678712845,
0.019313383847475052,
0.07756461948156357,
0.006400272715836763,
-0.014604184776544571,
-0.03324214741587639,
0.06733430176973343,
-0.0414... |
10e21391-d6bb-5d92-9c48-57091ec6c681 | /documentation/manage-data/payload/ | Payload | Payload types > Datetime | documentation | true | Payload > Payload types > Datetime
*Available as of v1.8.0*
`datetime` - date and time in [RFC 3339] format.
See the following examples of single and multiple `datetime` values:
```json
{
"created_at": "2023-02-08T10:49:00Z",
"updated_at": [
"2023-02-08T13:52:00Z",
"2023-02-21T21:23:00Z"
... | [
-0.01660081557929516,
-0.007401720620691776,
-0.03216765075922012,
-0.03304145112633705,
0.04325908049941063,
-0.014415579847991467,
0.009152376092970371,
0.036913949996232986,
0.07897061109542847,
-0.03788266330957413,
0.030313709750771523,
-0.04047726094722748,
0.050032906234264374,
-0.0... |
10fc09b4-8d95-5a94-8719-852111d098e6 | /course/essentials/day-4/what-is-quantization/ | Vector Quantization Methods | Scalar Quantization | course | true | Vector Quantization Methods > Scalar Quantization
[Scalar quantization](/articles/scalar-quantization/) maps each float32 dimension (4 bytes) to an int8 representation (1 byte), achieving 4x memory compression through learned range mapping. The algorithm analyzes your vector distribution and determines optimal bounds ... | [
0.06341604143381119,
-0.03234727308154106,
-0.052486520260572433,
-0.04264463111758232,
0.051044221967458725,
-0.0027752192690968513,
0.037645068019628525,
0.03552110120654106,
0.09964002668857574,
-0.026043185964226723,
0.03777123987674713,
-0.004195794463157654,
0.02870313823223114,
-0.0... |
11079494-8a0b-5a9b-8580-7d882086c777 | /documentation/search/search/ | Search | Pagination | documentation | true | Search > Pagination
The Search and [recommendation](/documentation/search/explore/#recommendation-api) APIs allow you to skip the first results and return only the results starting from a specified offset:
Example:
```python
client.query_points(
collection_name="{collection_name}",
query=[0.2, 0.1, 0.9, 0.7]... | [
0.03397517278790474,
-0.07287212461233139,
-0.03249138221144676,
-0.03395295515656471,
0.06992152333259583,
-0.04076104983687401,
0.06588653475046158,
0.0376301035284996,
0.05336257442831993,
-0.015276513062417507,
0.018541710451245308,
0.08476067334413528,
0.005133904982358217,
-0.0344130... |
11247dcc-370f-5951-b98a-75a35ef5b45e | /documentation/quickstart/ | Local Quickstart | Run a query | documentation | true | Local Quickstart > Run a query
Let's ask a basic question - Which of our stored vectors are most similar to the query vector `[0.2, 0.1, 0.9, 0.7]`?
```python
search_result = client.query_points(
collection_name="test_collection",
query=[0.2, 0.1, 0.9, 0.7],
with_payload=False,
limit=3
).points
print... | [
0.04650810360908508,
-0.04655000939965248,
-0.045808255672454834,
-0.017771629616618156,
0.05167749524116516,
-0.01613696850836277,
0.06464379280805588,
0.005213502794504166,
0.09137514978647232,
-0.052805811166763306,
0.03960932418704033,
0.03473746404051781,
0.024725589901208878,
0.01054... |
114bc85a-e8f0-51db-a7ed-a0eec73928c5 | /documentation/manage-data/vectors/ | Vectors | Datatypes > TurboQuant Datatypes > Turbo4 | documentation | true | Vectors > Datatypes > TurboQuant Datatypes > Turbo4
*Available as of v1.19.0*
The `turbo4` datatype stores each vector as a compact 4-bit representation per dimension instead of a 32-bit floating-point number. This shrinks vector storage to about one-eighth of its original size. Each rotated value is stored as one of... | [
0.037361592054367065,
-0.032694753259420395,
-0.03816956281661987,
-0.0341484360396862,
0.02373199351131916,
-0.0446321964263916,
0.022316720336675644,
0.06038603186607361,
0.058128416538238525,
-0.017184801399707794,
0.053216248750686646,
0.025369998067617416,
0.046802494674921036,
-0.003... |
1184b549-57bc-5998-84bf-c397b78ecc6e | /documentation/tutorials-operations/time-based-sharding/ | Time-Based Sharding | documentation | false | Time-Based Sharding
When working with massive, fast-moving datasets, like social media or image/video streams, efficient storage and retrieval are critical. Often, only the most recent data is relevant, while older data can be archived or deleted. For instance, in sentiment analysis of social media posts, you might on... | [
-0.015418595634400845,
-0.01738796941936016,
-0.048856984823942184,
-0.044095881283283234,
0.021394995972514153,
-0.03513463959097862,
0.03608822822570801,
-0.009904878214001656,
0.0892975702881813,
-0.025734977796673775,
0.026435190811753273,
0.01008947566151619,
0.04570163041353226,
-0.0... | |
11a13129-2a4d-5b36-bd5a-f7d9533dad24 | /documentation/embeddings/openai/ | OpenAI | Qdrant Cloud Inference | documentation | true | OpenAI > Qdrant Cloud Inference
On Qdrant Cloud, Qdrant can call OpenAI for you. Instead of a vector, send a `Document` with the model name prefixed with `openai/`. Pass your OpenAI API key in the `openai-api-key` request header or in the `options` object. Qdrant does not store the key, so send it with every request. ... | [
0.054038941860198975,
-0.04841054603457451,
-0.0008836642955429852,
-0.059937573969364166,
0.04478815197944641,
-0.030313951894640923,
0.07050895690917969,
0.07371117174625397,
0.05043140426278114,
-0.029078463092446327,
0.0039029293693602085,
0.014505913481116295,
0.05056125670671463,
-0.... |
11bdfdab-cbc1-55bc-94a1-cec3a184b2f6 | /documentation/edge/edge-api/snapshots/ | Snapshots | unpack_snapshot | documentation | true | Snapshots > unpack_snapshot
Unpacks a snapshot archive on disk so it can be loaded as a shard. A static method in Python and an associated function in Rust, so it needs no shard instance.
```python
@staticmethod
def unpack_snapshot(snapshot_path: str, target_path: str) -> None
```
| Parameter | Description |
| --- |... | [
0.014996208250522614,
-0.05142474174499512,
-0.02417675592005253,
-0.05138690024614334,
0.04042191430926323,
-0.00965042132884264,
0.04747895151376724,
0.04197833314538002,
0.05220849812030792,
-0.03141438961029053,
0.017300263047218323,
0.023955529555678368,
0.038254473358392715,
-0.00001... |
11caf16b-5b98-5a07-b5eb-d4022ea2d3da | /documentation/fastembed/fastembed-postprocessing/ | Multi-Vector Postprocessing | MUVERA | documentation | false | Multi-Vector Postprocessing > MUVERA
MUVERA transforms variable-length sequences of vectors into fixed-dimensional single-vector representations. These
approximations can be used for fast initial retrieval using traditional vector search methods like HNSW. Once you've
retrieved a small set of candidates quickly, you... | [
0.060665711760520935,
-0.06386110931634903,
-0.047022443264722824,
-0.06848888099193573,
0.05145632103085518,
-0.02050245739519596,
0.037679050117731094,
0.0030391078907996416,
0.08288367092609406,
-0.00013671965280082077,
-0.011819502338767052,
0.0418170802295208,
0.05516941100358963,
-0.... |
11cbfd13-0eeb-5b53-ba48-758106dad185 | /documentation/search/hybrid-queries/ | Hybrid Queries | Multi-Stage Queries | documentation | false | Hybrid Queries > Multi-Stage Queries
In general, larger vector representations give more accurate search results, but makes them more expensive to compute.
Splitting the search into two stages is a known technique to mitigate this effect:
- First, use a smaller and cheaper representation to get a large list of candi... | [
0.05499119684100151,
-0.03190961480140686,
-0.021581444889307022,
0.0048729432746768,
0.06854503601789474,
-0.024173656478524208,
0.03976808860898018,
0.009220893494784832,
0.06918802857398987,
-0.01864594779908657,
0.036954086273908615,
0.007771034725010395,
0.08291343599557877,
-0.027720... |
11ce075f-1c7f-5cca-88a2-ba562c65165e | /articles/predicting-weak-retrieval/ | Predicting Weak Retrieval Without an LLM | Adjacent Work | article | false | Predicting Weak Retrieval Without an LLM > Adjacent Work
This sits alongside corrective and adaptive retrieval. The difference is where the decision comes from: a cheap statistic of what was already retrieved, no extra model call, nothing to train.
- [Query performance prediction](https://arxiv.org/abs/2504.01101) ha... | [
0.0271613746881485,
-0.03249490261077881,
-0.05277548357844353,
-0.06251836568117142,
0.029504671692848206,
-0.0014309227699413896,
0.01561690866947174,
0.0017552010249346495,
0.0704079419374466,
-0.04092811048030853,
0.011444228701293468,
0.014131003990769386,
0.06194227933883667,
-0.0403... |
12008467-1805-5e10-b839-488a98b80f70 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search Beyond RAG > Big Unstructured Data Analysis | article | false | Why Vector Search Needs a Dedicated Database > Vector Search Beyond RAG > Big Unstructured Data Analysis
Vector search nature makes it also ideal for [**big unstructured data analysis**](https://www.youtube.com/watch?v=_BQTnXpuH-E), for instance, anomaly detection. In large, unstructured, and often unlabelled datasets... | [
0.03086329996585846,
-0.02582685463130474,
-0.09634079039096832,
-0.029318438842892647,
0.06346439570188522,
-0.023620640859007835,
0.058231059461832047,
0.02131929248571396,
0.05234568193554878,
0.0070517645217478275,
0.030025940388441086,
0.04053565114736557,
0.06897588074207306,
-0.0034... |
121063b5-f227-5ac2-93da-22319aeafd3e | /course/essentials/day-7/tensorlake/ | Integrating with Tensorlake | TensorLake Knowledge Graph Integration | course | false | Integrating with Tensorlake > TensorLake Knowledge Graph Integration
TensorLake introduces an innovative approach to enhancing Qdrant collection querying through advanced document parsing and knowledge graph creation. The platform transforms unstructured documents into structured knowledge graphs, providing comprehens... | [
0.040243953466415405,
-0.027329156175255775,
-0.08633780479431152,
-0.01715431921184063,
0.07622639834880829,
-0.01504927221685648,
0.06408726423978806,
0.0561104416847229,
0.03138665854930878,
-0.025418194010853767,
-0.0000413013985962607,
0.047488149255514145,
0.09277093410491943,
0.0175... |
12159391-e204-5ea5-a95f-a278fd6000c8 | /course/multi-vector-search/module-1/late-interaction-basics/ | Late Interaction Basics | Late Interaction: The Core Paradigm > The ColBERT Approach | course | true | Late Interaction Basics > Late Interaction: The Core Paradigm > The ColBERT Approach
The canonical implementation of late interaction is **ColBERT** (Contextualized Late Interaction over BERT), developed at Stanford. ColBERT popularized this paradigm and demonstrated that you can achieve cross-encoder-level effectiven... | [
0.03192978724837303,
-0.022904448211193085,
-0.03237112611532211,
-0.028621552512049675,
0.0794190838932991,
-0.024510767310857773,
0.06783997267484665,
0.02601809985935688,
0.08096954226493835,
-0.012263773940503597,
0.037984274327754974,
-0.019144095480442047,
0.027019575238227844,
-0.02... |
121735ee-f7ff-5e5a-8fb1-c092094eb36e | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Implementing Vector Search with Reranking > Implementation > Creating a Collection | documentation | true | Reranking for Better Search > Implementing Vector Search with Reranking > Implementation > Creating a Collection
A collection is basically a named group of points (vectors with data) that you can search through. All the vectors in a collection need to have the same size and be compared using one distance metric. Here’... | [
0.01824016682803631,
-0.033857908099889755,
-0.07314922660589218,
-0.05153011903166771,
0.06344357132911682,
-0.04533813148736954,
0.07870794832706451,
0.07451528310775757,
0.12344648689031601,
-0.051389072090387344,
0.022563878446817398,
0.05074511095881462,
0.04966540262103081,
-0.005986... |
1224de44-4545-5fc8-864e-e7a718cdf833 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Practical implementation in Python | article | false | Understanding SPLADE and Sparse Vectors > Practical implementation in Python
Let's dive into how Qdrant handles sparse vectors with an example. Here is what we will cover:
1. Setting Up Qdrant Client: Initially, we establish a connection with Qdrant using the QdrantClient.
2. Creating a Collection with Sparse Vector... | [
0.042648375034332275,
-0.07675568759441376,
-0.03278971090912819,
-0.007557150442153215,
0.05413259565830231,
-0.03630967065691948,
0.0626235380768776,
0.04010576754808426,
0.0756588950753212,
-0.03685349225997925,
0.011622927151620388,
0.03946620970964432,
0.0321459136903286,
0.0085477074... |
123b486c-c116-5631-b851-08f82c20e524 | /documentation/ops-monitoring/monitoring/ | Monitoring & Telemetry | Metrics > Node Metrics /metrics | documentation | false | Monitoring & Telemetry > Metrics > Node Metrics /metrics
| Name | Type | Meaning |
| --------------------------------------- | ------- | --------------------------------------------------------------------------- ... | [
-0.004726920276880264,
0.002024012617766857,
-0.04069258272647858,
-0.03462604805827141,
0.040994640439748764,
-0.013622194528579712,
0.05686813220381737,
0.05465869978070259,
0.08320123702287674,
-0.07257687300443649,
0.061264000833034515,
0.015240906737744808,
0.05108454450964928,
-0.027... |
123ba60f-83a8-5f22-ba80-b46e59471f9d | /documentation/manage-data/points/ | Points | Batch Update | documentation | true | Points > Batch Update
_Available as of v1.5.0_
You can batch multiple point update operations. This includes inserting,
updating and deleting points, vectors and payload.
A batch update request consists of a list of operations. These are executed in
order. These operations can be batched:
- [Upsert points](#upload-... | [
-0.0014100288972258568,
-0.04974624887108803,
-0.014451326802372932,
-0.015813559293746948,
0.04902279004454613,
-0.01742931269109249,
0.02925419807434082,
0.03723396360874176,
0.06803148984909058,
-0.029281826689839363,
0.0479346364736557,
0.05164336785674095,
0.006118249613791704,
-0.024... |
1256e7fe-7724-5851-811b-7ea60d6d021d | /articles/immutable-data-structures/ | Immutable Data Structures in Qdrant | How Does Immutability Help? > Defragmentation | article | false | Immutable Data Structures in Qdrant > How Does Immutability Help? > Defragmentation
| % of hot subset | Tenant Size (vectors) | RPS, Non-defragmented | RPS, Defragmented |
|-----------------|-----------------------|-----------------------|-------------------|
| 2.5% | 50k | 1.5 ... | [
0.055433474481105804,
-0.027769548818469048,
-0.06775262951850891,
-0.03756461292505264,
0.04865219444036484,
-0.0546935573220253,
0.05337980389595032,
0.058343976736068726,
0.11211195588111877,
-0.028809545561671257,
0.013369453139603138,
-0.0049832663498818874,
0.04931606352329254,
-0.02... |
125889f6-fc4a-5314-a243-4fca7bdf82ad | /articles/hyperbolic-embeddings-qdrant/ | Why Hyperbolic Embeddings Matter for Hierarchical Data | Superpowers of Hyperbolic Embeddings > Radius Can Encode Specificity | article | false | Why Hyperbolic Embeddings Matter for Hierarchical Data > Superpowers of Hyperbolic Embeddings > Radius Can Encode Specificity
One of the nicest properties of a hierarchy-aware hyperbolic embedding is that radius can start to mean something.
Closer to the center, you can place broad concepts. Farther out, you can plac... | [
0.05399831384420395,
-0.009497164748609066,
-0.05867929756641388,
-0.08860576897859573,
0.08919274061918259,
-0.036955252289772034,
0.058287519961595535,
0.02828102372586727,
0.05836692824959755,
-0.0213070809841156,
0.02250383235514164,
0.011415675282478333,
0.08576085418462753,
-0.045148... |
126dfdc4-c0f6-58b0-bd02-57db04849703 | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | Payload Indexing: The Base Layer | course | true | Combining Vector Search and Filtering > Payload Indexing: The Base Layer
**Critical point:** Qdrant does not index payload fields by default. You must explicitly define which fields to index. Best practice is to create payload indexes before uploading any data so HNSW can build filter-aware links. If you add payload i... | [
0.021955382078886032,
-0.030967453494668007,
-0.05640288069844246,
-0.030670462176203728,
0.06103925779461861,
-0.0419478714466095,
0.06277108937501907,
0.03389076516032219,
0.0722111240029335,
-0.02490081638097763,
0.033678874373435974,
0.03276035934686661,
0.03290562704205513,
-0.0307668... |
1272b0a5-bddc-5c25-8cdc-3483481d03ce | /documentation/manage-data/vectors/ | Vectors | Vector Types > Dense Vectors | documentation | true | Vectors > Vector Types > Dense Vectors
This is the most common type of vector. It is a simple list of numbers, it has a fixed length and each element of the list is a floating-point number.
It looks like this:
```json
// A piece of a real-world dense vector
[
-0.013052909,
0.020387933,
-0.007869,
-0... | [
0.032134439796209335,
-0.007261054590344429,
-0.05255191773176193,
-0.03886978700757027,
0.018679866567254066,
-0.07933443039655685,
0.046334486454725266,
0.09810338169336319,
0.12599794566631317,
-0.043188489973545074,
0.033526189625263214,
0.06427884101867676,
0.047862812876701355,
-0.02... |
127719a8-f1ab-52b3-afb5-bb28c65b7298 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-1/ | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS | documentation | false | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS
| Time: 90 min | Level: Advanced | Output: [GitHub](https://github.com/qdrant/video-anomaly-edge) |
| --- | ----------- | ----------- |
*This is Part 1 of a 3-part series on building real-time video anomaly detection from edge to cloud. We'll g... | [
0.027407530695199966,
-0.025623204186558723,
-0.09040658175945282,
-0.030124083161354065,
0.08163192123174667,
-0.008859153836965561,
0.051927097141742706,
0.02051962912082672,
0.07384581118822098,
-0.04108568653464317,
0.06820708513259888,
0.007006249390542507,
0.054011911153793335,
-0.03... | |
12c6ca91-0482-598c-83bc-d7d3f88abbe7 | /documentation/tutorials-basics/reranking-hybrid-search/ | Hybrid Search with Reranking | Overview > Ingestion Stage | documentation | false | Hybrid Search with Reranking > Overview > Ingestion Stage
You'll start by ingesting a CSV file containing information about science fiction books. Each row is a **document**, corresponding to a book, with fields for the title, author, and description. Each book description will be indexed in three ways:
- **Dense embe... | [
0.043774235993623734,
-0.02428140491247177,
-0.06716533750295639,
-0.04790119826793671,
0.0823201909661293,
-0.017285101115703583,
0.05590525642037392,
0.030627287924289703,
0.07211793959140778,
0.0018229731358587742,
0.022907644510269165,
-0.0011113599175587296,
0.053725939244031906,
-0.0... |
12cb95ca-33d7-5b39-8420-98496c709a28 | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Points Count | documentation | true | Administration > Strict Mode > Maximum Points Count
Setting `max_points_count` caps the maximum number of points for a collection.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
client.create_collection(
collection_name="{collection_name}",
strict... | [
0.006410231348127127,
-0.018518676981329918,
-0.009819718077778816,
-0.0246563907712698,
0.05473083630204201,
-0.032380230724811554,
0.01807130128145218,
0.0639915019273758,
0.08359210193157196,
-0.036897171288728714,
0.020128540694713593,
0.0003747719747480005,
0.062018703669309616,
-0.05... |
12d850d8-b589-5cef-a752-0f9c6cf3a7de | /documentation/search-patterns/vector-search-filtering/ | Filtering in Vector Search: When to Use What | Turn On ACORN for Strict Combined Filters | documentation | true | Filtering in Vector Search: When to Use What > Turn On ACORN for Strict Combined Filters
Filterable HNSW builds extra edges for each indexed field separately, not for combinations of fields. When a query combines two or more strict filters, the points that satisfy all of them may not be connected in the graph, and rec... | [
0.04930904507637024,
-0.08194439858198166,
-0.06170564144849777,
-0.029991088435053825,
0.06111377477645874,
-0.010354769416153431,
0.055344488471746445,
-0.005995132029056549,
0.06505218893289566,
-0.005927348509430885,
0.07183142006397247,
0.02882818877696991,
0.03855212777853012,
-0.023... |
12e5c989-f062-58a1-a80f-e485190aef1c | /documentation/manage-data/payload/ | Payload | Payload indexing | documentation | true | Payload > Payload indexing
To search more efficiently with filters, Qdrant allows you to create indexes for payload fields by specifying the name and type of field it is intended to be.
The indexed fields also affect the vector index. See [Indexing](/documentation/manage-data/indexing/) for details.
In practice, we ... | [
0.03920513764023781,
-0.03465931862592697,
-0.04207375645637512,
-0.024697862565517426,
0.05739031359553337,
-0.04955236613750458,
0.056884124875068665,
0.05278545618057251,
0.0792502611875534,
-0.05650496110320091,
0.023072708398103714,
0.03419075906276703,
0.030057383701205254,
-0.027875... |
12eb54b3-d6d1-5e2a-ba76-7376d04e46da | /documentation/tutorials-build-essentials/video-anomaly-edge-part-3/ | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment | Unified Retrieval: Querying Across Time, Cameras, and Sites | documentation | false | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment > Unified Retrieval: Querying Across Time, Cameras, and Sites
The centralized Qdrant cluster is not just a scoring backend. It is a retrieval layer that indexes every embedding the system produces. Each vector carries payload metadata: `source_video`,... | [
0.07222270965576172,
-0.07278016209602356,
-0.09574076533317566,
-0.03864070773124695,
0.07038687914609909,
-0.0009901331504806876,
0.06620648503303528,
0.01748223602771759,
0.05624007806181908,
-0.019114172086119652,
0.043532781302928925,
-0.005896890070289373,
0.059696439653635025,
-0.02... |
12ee0ced-9c3f-5010-9385-19f5335bba94 | /documentation/tutorials-build-essentials/agentic-rag-langgraph/ | Agentic RAG with LangGraph | What We’ll Build | documentation | false | Agentic RAG with LangGraph > What We’ll Build
We’re building an AI agent to answer questions about Hugging Face and Transformers documentation using LangGraph. At the heart of our AI agent lies LangGraph, which acts like a conductor in an orchestra. It directs the flow between various components—deciding when to retri... | [
-0.0006502159521915019,
-0.042210910469293594,
-0.07111652195453644,
-0.027703547850251198,
0.0751822292804718,
-0.05564381554722786,
0.04773924499750137,
0.04146287217736244,
0.0235702283680439,
-0.03362734243273735,
0.016878949478268623,
0.05037260428071022,
0.056437380611896515,
-0.0198... |
12f3589c-0d0c-5206-a5c4-07c214668ba6 | /documentation/hybrid-cloud/hybrid-cloud-cluster-creation/ | Create a Cluster | documentation | false | Create a Cluster
Once a Hybrid Cloud Environment has been created you can follow the normal process to [create a Qdrant cluster](/documentation/cloud/create-cluster/) in that environment. This page also contains additional information on how to create a [production-ready cluster](/documentation/cloud/create-cluster/#c... | [
0.02700326405465603,
-0.018456146121025085,
-0.04496638476848602,
-0.056955188512802124,
0.04503334313631058,
-0.04041826352477074,
0.06119154766201973,
0.0385701060295105,
0.05739185959100723,
-0.055051397532224655,
0.0418299101293087,
-0.001623844844289124,
0.05793505162000656,
-0.024438... | |
132715bf-e555-58f0-abaf-1a29c9de80c4 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Objections to a Dedicated Service > When the extension is the right call | article | false | Why Vector Search Needs a Dedicated Database > Objections to a Dedicated Service > When the extension is the right call
If you have a small amount of data, simple similarity search, and a database that already supports vectors, start there. It is the fastest way to prototype, and you can move to a dedicated service la... | [
-0.004387929104268551,
-0.060344524681568146,
-0.047535866498947144,
-0.0285035353153944,
0.018051302060484886,
-0.04454636573791504,
0.06509321182966232,
0.023153960704803467,
0.04997202008962631,
-0.009897654876112938,
0.02020174078643322,
0.05863633751869202,
0.03927595913410187,
-0.015... |
13368ae8-ab39-5c71-aced-6aa2d7d22d91 | /documentation/frameworks/sycamore/ | Sycamore | Writing to Qdrant | documentation | true | Sycamore > Writing to Qdrant
To write a Docset to a Qdrant collection in Sycamore, use the `docset.write.qdrant(....)` function. The Qdrant writer accepts the following arguments:
- `client_params`: Parameters that are passed to the Qdrant client constructor. See more information in the [Client API Reference](https:/... | [
0.006409764755517244,
-0.06000514701008797,
-0.016086900606751442,
-0.015481512062251568,
0.06310777366161346,
-0.04110619053244591,
0.05624624714255333,
0.05067656189203262,
0.06506606936454773,
-0.014548011124134064,
0.02665049582719803,
0.03236204758286476,
0.022326279431581497,
-0.0408... |
134f86b8-cd00-5225-8407-6629fed91b0b | /course/multi-vector-search/module-3/muvera/ | MUVERA | Applying MUVERA Multi-Stage Retrieval > Embedding and Indexing Documents | course | true | MUVERA > Applying MUVERA Multi-Stage Retrieval > Embedding and Indexing Documents
Next, embed your documents and upload both representations. Generate multi-vector embeddings with ColModernVBERT, then process them through MUVERA:
```python
# Embed documents
image_path = "images/financial-report.png"
doc_multivec = li... | [
0.04061915725469589,
-0.03817175701260567,
-0.019032709300518036,
-0.051801931113004684,
0.0763283520936966,
0.006713577080518007,
0.05889786779880524,
0.06444021314382553,
0.03370818868279457,
0.026216987520456314,
0.015577968209981918,
0.035173553973436356,
0.040291137993335724,
-0.03070... |
1391f8f4-ad48-5986-852d-6f2f4d305d6d | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Adding Relevance Feedback Query to a Search Pipeline > 4. Combining all the Steps | documentation | false | Relevance Feedback Retrieval in Qdrant > Adding Relevance Feedback Query to a Search Pipeline > 4. Combining all the Steps
Now you can use Relevance Feedback Query results in different ways:
- **Combine with initial retrieval**, for example, rerank the union of both result sets with the feedback model.
- **Use as you... | [
0.03059956803917885,
-0.04921391233801842,
-0.038433678448200226,
-0.04950108006596565,
0.05652933195233345,
-0.033713195472955704,
0.05347743630409241,
0.02160765416920185,
0.068558469414711,
-0.013989508152008057,
0.03320714086294174,
0.009565678425133228,
0.05208779126405716,
-0.0266963... |
13bba31b-6a5e-5486-8156-04cf4833a809 | /documentation/ops-monitoring/hybrid-cloud-prometheus/ | Monitoring with Grafana and Prometheus | Step 3: Check That Prometheus Sees the Targets | documentation | true | Monitoring with Grafana and Prometheus > Step 3: Check That Prometheus Sees the Targets
Before you build any dashboards, confirm that Prometheus discovered the Qdrant targets and can query a metric from them.
Port-forward the Prometheus service:
```bash
kubectl --namespace monitoring port-forward svc/prometheus-kube... | [
0.04770662263035774,
-0.030593153089284897,
-0.026362337172031403,
0.04149630665779114,
0.06917642056941986,
-0.022386880591511726,
0.07242609560489655,
0.033655837178230286,
0.03506210446357727,
-0.027181822806596756,
0.04162822291254997,
0.004119838122278452,
0.07892321050167084,
-0.0218... |
13cd9e18-6990-590e-8db7-17683573710c | /documentation/tutorials-operations/scaling-and-monitoring-pods/ | Scaling and Monitoring Hybrid Cloud | Know What to Monitor Before You Scale | documentation | false | Scaling and Monitoring Hybrid Cloud > Know What to Monitor Before You Scale
Scaling on a hunch wastes money in one direction and risks an outage in the other. Check actual usage first, against the same resource numbers you just read from `qcloud cluster describe`.
Qdrant Cloud exposes two Prometheus-compatible endpoi... | [
0.03548634797334671,
-0.0064575448632240295,
-0.06108791381120682,
-0.04931939020752907,
0.07047763466835022,
-0.01727456785738468,
0.05291344225406647,
0.029876837506890297,
0.0942830741405487,
-0.05594683811068535,
0.029531294479966164,
-0.032440196722745895,
0.05995270609855652,
-0.0059... |
13d4a4cc-2461-5d4e-926f-6991c18e3b03 | /course/essentials/day-4/rescoring-oversampling-indexing/ | Accuracy Recovery with Rescoring | Rescoring | course | false | Accuracy Recovery with Rescoring > Rescoring
After oversampling to gather more potential matches, each candidate is re-evaluated based on additional criteria to ensure higher accuracy and relevance to the query. The rescoring process maps the quantized vectors to their corresponding original vectors, allowing you to c... | [
0.04564240947365761,
-0.07404240220785141,
-0.0478992722928524,
-0.053349949419498444,
0.0723525732755661,
0.0021030325442552567,
0.02657770738005638,
-0.004534528125077486,
0.07923667132854462,
-0.03353637084364891,
0.030288079753518105,
0.03751799464225769,
0.07546328753232956,
-0.006278... |
13efc209-d767-562f-85a1-6dc98e2b59c8 | /course/beginners/module-0/building-simple-vector-search/ | Implementing a Basic Vector Search | course | false | Implementing a Basic Vector Search
Module 0
In this lesson you'll build your very first search, one small step at a time. You'll connect to Qdrant, create a place to store data, add a few example vectors, and then ask Qdrant to find the closest match. Every step has runnable code, so follow along in a notebook or scr... | [
0.04281353950500488,
-0.0854460746049881,
-0.0324699841439724,
-0.0073398808017373085,
0.07022284716367722,
-0.036455001682043076,
0.03497488051652908,
0.027345729991793633,
0.0502629391849041,
-0.0208550114184618,
0.04642695188522339,
0.03577420860528946,
0.04752881079912186,
-0.036912884... | |
13f3767f-526f-57e9-971b-d75ce0de5382 | /course/essentials/day-2/pitstop-project/ | Project: HNSW Performance Benchmarking | What You'll Build | course | false | Project: HNSW Performance Benchmarking > What You'll Build
A performance-optimized version of your Day 1 search engine that demonstrates:
- **Fast bulk load**: Load with `m=0`, then switch to HNSW
- **HNSW parameter tuning**: Try different `m` and `ef_construct`
- **Payload indexing impact**: Time filtering with and ... | [
0.047462452203035355,
-0.025237230584025383,
-0.05950647220015526,
-0.005502954125404358,
0.06903965771198273,
-0.05090026184916496,
0.04275849089026451,
0.024648861959576607,
0.06903303414583206,
-0.03388453647494316,
0.032965246587991714,
0.03360050916671753,
0.06203712522983551,
-0.0586... |
13f9af89-8166-5d15-987b-ca8c2a85cca4 | /course/essentials/day-1/chunking-strategies/ | Text Chunking Strategies | Text Chunking Strategy Comparison | course | false | Text Chunking Strategies > Text Chunking Strategy Comparison
| Method | Strength | Trade-off | Best For |
|--------|----------|-----------|----------|
| **Fixed-Size** | Simple, predictable chunks | Ignores structure, breaks meaning | Raw or unstructured text |
| **Sentence** | Preserves complete thoughts | Inconsiste... | [
0.006654665339738131,
-0.026667414233088493,
-0.0831802487373352,
-0.0663006454706192,
0.03804484009742737,
-0.05072103440761566,
0.04001536965370178,
0.0014389522839337587,
0.06731779873371124,
-0.02880133129656315,
0.005758457817137241,
-0.004733141977339983,
0.05545317754149437,
-0.0238... |
140b1c0b-279f-5cd9-8c5e-25bf35eaf320 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > EntityPhase | documentation | false | API Reference > qdrant.io/v1 > Resource Types > EntityPhase
_Underlying type:_ _string_
_Appears in:_
- [QdrantEntityStatus](#qdrantentitystatus)
| Field | Description |
| --- | --- |
| `Creating` | |
| `Ready` | |
| `Updating` | |
| `Failing` | |
| `Deleting` | |
| `Deleted` | | | [
0.030880948528647423,
-0.05888345092535019,
-0.012866712175309658,
-0.08410102128982544,
0.08744237571954727,
-0.03958119451999664,
0.020592015236616135,
0.050780039280653,
0.06830047070980072,
-0.04858269914984703,
0.047712866216897964,
-0.001102789188735187,
0.06389585882425308,
-0.03533... |
14123c9f-d08e-51b4-8144-85d4fec3b168 | /documentation/manage-data/points/ | Points | Upload Points > Python Client Optimizations | documentation | true | Points > Upload Points > Python Client Optimizations
The Python client has additional features for loading points, which include:
- Parallelization
- A retry mechanism
- Lazy batching support
For example, you can read your data directly from hard drives, to avoid storing all data in RAM. You can use these
features w... | [
-0.0032197043765336275,
-0.060831598937511444,
-0.017298605293035507,
-0.050679437816143036,
0.09326595067977905,
-0.06225299835205078,
0.055418990552425385,
0.0524984709918499,
0.09243956953287125,
-0.03159244358539581,
0.014307113364338875,
0.023219775408506393,
0.040251024067401886,
-0.... |
141ba9cb-b132-5412-9925-aba04856d440 | /documentation/manage-data/indexing/ | Indexing | Full-Text Index > Stemmer | documentation | true | Indexing > Full-Text Index > Stemmer
A **stemmer** is an algorithm used in text processing to reduce words to their root or base form, known as the "stem." For example, the words "running", "runner and "runs" can all be reduced to the stem "run."
When configuring a full-text index in Qdrant, you can specify a stemmer... | [
0.03486318141222,
-0.026254495605826378,
-0.02693653106689453,
-0.033344630151987076,
0.04643149673938751,
-0.007434424478560686,
0.03622052073478699,
0.029899045825004578,
0.03757844492793083,
-0.027772732079029083,
0.08149528503417969,
0.014881128445267677,
0.04592016339302063,
-0.042657... |
144fa852-463f-5ca6-b23f-0faf6f8fd6ca | /documentation/examples/rag-contract-management-stackit-cohere/ | Region-Specific Contract Management System | Implementation > Ingestion pipeline | documentation | true | Region-Specific Contract Management System > Implementation > Ingestion pipeline
Semantic search systems rely on high-quality data as their foundation. It's crucial to split the text intelligently to avoid converting entire documents into vectors; instead, they should be divided into meaningful chunks. Each chunk is c... | [
0.02773256227374077,
-0.044815611094236374,
-0.06891954690217972,
-0.0211302749812603,
0.062365978956222534,
-0.033778004348278046,
0.046555452048778534,
0.02447732351720333,
0.06080411374568939,
-0.01944824494421482,
0.01058404240757227,
0.0012658328050747514,
0.03111948072910309,
-0.0575... |
146fcc2d-b159-5aad-907a-4efefff19106 | /documentation/frameworks/microsoft-graphrag/ | Microsoft GraphRAG | documentation | true | Microsoft GraphRAG
[Microsoft GraphRAG](https://github.com/microsoft/graphrag) is a Python library for building knowledge graphs from unstructured text and using them for retrieval-augmented generation. It combines graph-based indexing with vector search to improve the quality and relevance of LLM responses.
Qdrant c... | [
0.023416748270392418,
-0.03334466367959976,
-0.04780525341629982,
-0.031389299780130386,
0.08686164766550064,
-0.052792154252529144,
0.07061443477869034,
0.07097340375185013,
0.04033989831805229,
-0.06967542320489883,
-0.0002611514937598258,
0.029964575543999672,
0.07388976216316223,
-0.02... | |
147a457f-8133-552e-81b4-502e94aa1eb8 | /documentation/tutorials-search-engineering/query-decomposition/ | Query Decomposition for Multi-Hop Questions | When to Use It | documentation | false | Query Decomposition for Multi-Hop Questions > When to Use It
Decomposition adds an LLM call and a query per hop, so reach for it only when a question spans multiple facts. For single-fact questions, one query is faster and usually just as accurate. To confirm it helps on your data, compare `recall@k` for single-pass a... | [
0.006865346804261208,
-0.04803231358528137,
-0.03944612666964531,
-0.055287718772888184,
0.030492382124066353,
0.007531102746725082,
0.028694190084934235,
0.018860310316085815,
0.07434327155351639,
-0.016865182667970657,
0.0445723794400692,
0.008795755915343761,
0.028231825679540634,
0.007... |
148cb5cf-8bb5-5046-bb9c-d8f463d8ae53 | /course/beginners/ | Qdrant Beginner Course | How the Course Works | course | false | Qdrant Beginner Course > How the Course Works
- icon: /icons/outline/training-purple.svg
title: Bite-sized lessons
content: Short, friendly modules you can finish in one sitting
- icon: /icons/outline/hacker-purple.svg
title: Learn by doing
content: Follow along with real examples and hands-on exercises
- icon... | [
0.01933024637401104,
-0.04290521889925003,
-0.06420513242483139,
-0.031731732189655304,
0.056662362068891525,
-0.0005541272112168372,
0.04547661170363426,
0.06772047281265259,
0.03137138485908508,
0.0013214984210208058,
0.011790234595537186,
0.04437795281410217,
0.039707932621240616,
-0.04... |
14910047-e6a7-538e-9b15-aedd47de5e0f | /documentation/tutorials-build-essentials/agentic-rag-langgraph/ | Agentic RAG with LangGraph | Workflow | documentation | false | Agentic RAG with LangGraph > Workflow
 back [sparse vector search](/documentation/search/text-search/sparse-vector-search/). They also have an index, which is an inverted-index-style structure.
If you're using sparse vect... | [
0.04099710285663605,
-0.060203917324543,
-0.02935582958161831,
-0.03873806446790695,
0.058836568146944046,
-0.018551016226410866,
0.07473539561033249,
0.0034138222690671682,
0.0895339697599411,
-0.023090222850441933,
0.009526033885776997,
0.04970339313149452,
0.03193586319684982,
-0.003265... |
14b4476b-c216-5e46-8aa7-95de25f75c61 | /documentation/search/explore/ | Explore | Batch Recommendation API | documentation | true | Explore > Batch Recommendation API
*Available as of v0.10.0*
Similar to the batch search API in terms of usage and advantages, it enables the batching of recommendation requests.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="http://localhost:6333")
filter_ = models.Filter(
... | [
-0.05260045453906059,
-0.057022031396627426,
-0.04837958514690399,
-0.08328857272863388,
0.08123066276311874,
-0.019603587687015533,
0.031371068209409714,
0.07009042054414749,
0.07456660270690918,
-0.03924277052283287,
0.06075082719326019,
0.05078398808836937,
0.07632402330636978,
-0.02453... |
14d21bee-f2a1-5f78-8d64-1ea44da964b3 | /documentation/manage-data/payload/ | Payload | Payload types > Float | documentation | true | Payload > Payload types > Float
`float` - 64-bit floating point number.
Example of single and multiple `float` values:
```json
{
"price": 11.99,
"ratings": [9.1, 9.2, 9.4]
}
``` | [
0.0011145187309011817,
-0.016848206520080566,
-0.04937639832496643,
-0.05746909976005554,
0.0562598779797554,
-0.038322918117046356,
-0.023528555408120155,
0.05348844826221466,
0.09580910950899124,
-0.026997651904821396,
0.028028447180986404,
-0.05330684781074524,
0.027361907064914703,
-0.... |
14dd8167-28a3-56de-baeb-6b129dddbc4d | /articles/filterable-hnsw/ | Filterable HNSW Without Recall Loss | How can we modify it? | article | false | Filterable HNSW Without Recall Loss > How can we modify it?
What if we simply apply the filter criteria to the nodes of this graph and use in the greedy search only those that meet these criteria?
It turns out that even with this naive modification algorithm can cover some use cases.
One such case is if your criteria... | [
0.07908733934164047,
-0.04788866639137268,
-0.03395963832736015,
-0.032603539526462555,
0.036180008202791214,
-0.009403428062796593,
0.03534884750843048,
0.041831377893686295,
0.07760890573263168,
-0.013789373449981213,
0.0334620364010334,
0.02058606781065464,
0.08256714791059494,
-0.02091... |
14e928e4-1813-5b43-8de8-689dbd0e2ee8 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Practical implementation in Python > 3. Insert sparse vectors | article | true | Understanding SPLADE and Sparse Vectors > Practical implementation in Python > 3. Insert sparse vectors
Here, we see the process of inserting a sparse vector into the Qdrant collection. This step is key to building a dataset that can be quickly retrieved in the first stage of the retrieval process, utilizing the effic... | [
0.046366699039936066,
-0.04514392837882042,
-0.018608586862683296,
-0.020238369703292847,
0.05532080680131912,
-0.03856317698955536,
0.04378335922956467,
0.04148632660508156,
0.06916604936122894,
-0.047293975949287415,
0.0059663886204361916,
0.044237177819013596,
0.030101345852017403,
-0.0... |
151fcb81-4fc0-5069-b6e3-d4a953aa9752 | /documentation/embeddings/ollama/ | Ollama | Reduce Vector Size | documentation | true | Ollama > Reduce Vector Size
`embed` accepts a `dimensions` parameter. Ollama keeps the leading values of each vector and normalizes the result again. Use it only with models trained for shortened vectors, such as `qwen3-embedding`, `embeddinggemma-2`, and `nomic-embed-text-v2-moe`. Set the collection's `size` to the s... | [
0.06469159573316574,
-0.029607292264699936,
-0.043004658073186874,
-0.0834364965558052,
0.06377893686294556,
-0.03234655410051346,
0.08506198227405548,
0.05764758214354515,
0.04434351995587349,
-0.0070708440616726875,
0.014068598859012127,
0.01896725781261921,
0.0389925055205822,
-0.021066... |
152224eb-8c9d-542f-9b4d-55d6c6835a93 | /articles/filtered-vector-search-acorn/ | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN | Further Reading | article | false | Filtered Vector Search: What ACORN Fixes, and What Fixes ACORN > Further Reading
- [ACORN (Patel et al., SIGMOD 2024)](https://arxiv.org/abs/2403.04871): the paper behind ACORN-gamma and ACORN-1.
- [RACORN-1](https://arxiv.org/abs/2607.00768): a follow-up targeting ACORN-1's recall collapse at low selectivity.
- [Post... | [
0.06047863885760307,
-0.06968335062265396,
-0.06078881397843361,
-0.03239566460251808,
0.05966360867023468,
0.015929555520415306,
0.05284905806183815,
0.01643708348274231,
0.06560789048671722,
-0.01467566192150116,
0.04834212735295296,
0.04135748744010925,
0.057033225893974304,
-0.03020395... |
15232abb-c039-5a3d-ac10-b84e3dde55ec | /course/essentials/day-5/pitstop-project/ | Project: Building a Recommendation System | Build Steps > Step 4: Build a Recommendation Service | course | true | Project: Building a Recommendation System > Build Steps > Step 4: Build a Recommendation Service
Now let's wrap everything into a production-ready function that handles dynamic user preferences.
#### Helper Function for Building Filters
First, create a reusable helper function to build filters from user profiles:
`... | [
0.011179191060364246,
-0.01779329776763916,
-0.027902889996767044,
-0.06852372735738754,
0.07297629863023758,
-0.04256424307823181,
0.03188438341021538,
0.0566360242664814,
0.07284893840551376,
-0.017117125913500786,
0.053385455161333084,
0.02336515486240387,
0.08413711190223694,
-0.059696... |
1525cae2-ea37-5713-a60e-d8aefdf07cf6 | /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.027966877445578575,
-0.04124310240149498,
-0.032668281346559525,
0.017264289781451225,
0.07604067772626877,
-0.0667719617486,
0.05313195288181305,
0.07438596338033676,
0.06276407092809677,
-0.04367397353053093,
0.032997261732816696,
-0.00902381632477045,
0.023703964427113533,
-0.02565206... |
1526a551-2f22-5647-8f78-0b8f532b95f8 | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | Implementing Multi-Modal Search with FastEmbed and Qdrant > Setting Up Qdrant for Multi-Vector Search | course | true | How ColPali Models Work > Implementing Multi-Modal Search with FastEmbed and Qdrant > Setting Up Qdrant for Multi-Vector Search
To store and search these multi-vector embeddings, we need a Qdrant collection configured for late interaction:
```python
from qdrant_client import QdrantClient, models
client = QdrantClien... | [
0.047290101647377014,
-0.03198130428791046,
-0.014463498257100582,
-0.024083741009235382,
0.06883447617292404,
-0.04765436425805092,
0.08041081577539444,
0.046699702739715576,
0.04786356911063194,
-0.006933476310223341,
0.03247027471661568,
0.028512341901659966,
0.06790154427289963,
-0.033... |
1528066d-24b2-5041-b0fe-1971f7ca5501 | /documentation/security/ | Security | Audit Logging > Query Audit Logs | documentation | true | Security > Audit Logging > Query Audit Logs
*Available as of v1.18.0*
The audit log can be queried via the `/audit/logs` API (requires [manage-level access](#table-of-access)). The API reads the entries that Qdrant wrote to files. If `output` is `stdout` or `stderr`, there are no local files to read, so the API retur... | [
0.01908707432448864,
-0.05945025384426117,
-0.0004444954975042492,
-0.026697862893342972,
0.07161503285169601,
-0.04198426753282547,
0.020752698183059692,
0.04609247297048569,
0.07346219569444656,
-0.03741917759180069,
0.010623288340866566,
0.026457490399479866,
0.055520083755254745,
-0.02... |
15368146-9346-5411-a0b7-f360384db009 | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 3: Change Data Capture with Debezium + Redpanda > The WAL Disk Bloat Problem | documentation | true | Keeping Postgres and Qdrant in Sync > Tier 3: Change Data Capture with Debezium + Redpanda > The WAL Disk Bloat Problem
One operational hazard specific to CDC: Postgres holds WAL segments until the replication slot consumer acknowledges them. If your consumer is down for a long time, Postgres can accumulate significan... | [
0.026626605540513992,
-0.036273010075092316,
0.012023058719933033,
-0.04655846953392029,
0.03610905632376671,
-0.06399775296449661,
0.04350253567099571,
0.05911757051944733,
0.07293680310249329,
-0.01389120053499937,
0.0400344580411911,
-0.0029567237943410873,
0.03812259063124657,
-0.03850... |
156f7446-7145-52dc-b206-8eb775d7be76 | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | Step 2: Connect to Qdrant Cloud | course | true | Demo: HNSW Performance Tuning > Step 2: Connect to Qdrant Cloud
We’ll use Qdrant Cloud for stable resources at 100K scale.
```python
from datasets import load_dataset
from qdrant_client import QdrantClient, models
from tqdm import tqdm
import openai
import time
import os
client = QdrantClient(
url=os.getenv("QDR... | [
0.026692235842347145,
-0.027766212821006775,
-0.04377352446317673,
-0.04510757699608803,
0.020167775452136993,
-0.02995937317609787,
0.07021182775497437,
0.0029222629964351654,
0.07152708619832993,
-0.018571048974990845,
0.01453318540006876,
-0.017981363460421562,
0.06634723395109177,
-0.0... |
15a75a64-5233-5eb5-b543-a5c6dc5573a4 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Compare RRF and DBSF on Your Labels | documentation | false | How to Tune Hybrid Search in Qdrant > Compare RRF and DBSF on Your Labels
DBSF takes no parameters: `k` and the weight pair are RRF settings, and the public API accepts them only on an `RrfQuery`. So if DBSF wins on your labels, skip the next two sections and go to the held-out check. | [
0.01905001886188984,
-0.021497908979654312,
-0.008798175491392612,
-0.0692906379699707,
0.05303768441081047,
-0.07109887897968292,
0.037736885249614716,
0.04335504397749901,
0.03470723703503609,
-0.026175057515501976,
0.02931233122944832,
0.017211925238370895,
0.04889768362045288,
0.009809... |
15a846e1-63a6-58d9-8c9e-f5a6cb7b6bb5 | /documentation/edge/edge-api/shard-lifecycle/ | Shard Lifecycle | documentation | false | Shard Lifecycle
An Edge Shard is backed by a directory on local disk. The lifecycle of a shard is:
1. **Create** a new shard with `EdgeShard.create` (Python) or `EdgeShard::new` (Rust), or **load** an existing one with `load`.
2. **Use** the shard to update and query data.
3. **Flush** pending changes to disk, and **... | [
-0.002926647663116455,
-0.01855524815618992,
-0.03536487743258476,
-0.00963427871465683,
0.08663482964038849,
-0.05758550763130188,
0.06323336809873581,
0.006495640147477388,
0.0866319090127945,
-0.031119590625166893,
0.029699768871068954,
0.02059042826294899,
0.02754434011876583,
-0.00723... | |
15d2eb0f-563d-5cdc-8c90-00168ded8d0e | /articles/filterable-hnsw/ | Filterable HNSW Without Recall Loss | article | false | Filterable HNSW Without Recall Loss
The [original paper](https://arxiv.org/abs/1603.09320) is well written and very easy to read, so I will only give the main idea here.
We need to build a navigation graph among all indexed points so that the greedy search on this graph will lead us to the nearest point.
This graph is... | [
0.0272305179387331,
-0.05060648173093796,
-0.044639673084020615,
-0.022257531061768532,
0.04955638200044632,
-0.03546867147088051,
0.05373241379857063,
0.07349913567304611,
0.0487917959690094,
-0.008084956556558609,
0.03187786415219307,
0.04935001954436302,
0.06226107478141785,
0.012443056... | |
15dcb2fa-0847-56f2-a3e8-bdaef493d093 | /documentation/search-tuning/when-a-reranker-is-worth-it/ | When Is a Reranker Worth It? | Size Reranking for Production | documentation | false | When Is a Reranker Worth It? > Size Reranking for Production
Once relevance has settled the candidate count and the model, measure query-candidate pairs per second and tail latency on the hardware you plan to deploy, using representative document lengths and concurrency.
The table shows CPU throughput for the four [F... | [
0.031745076179504395,
-0.02964397519826889,
-0.0696251317858696,
-0.04781866818666458,
0.0659003034234047,
-0.024632804095745087,
0.06061907485127449,
0.05150892212986946,
0.07584403455257416,
-0.04350728914141655,
0.014160199090838432,
-0.004207194782793522,
0.06002384424209595,
-0.020504... |
15e73739-8bc1-5b9e-9dcc-631fa55d9a85 | /documentation/search/search-relevance/ | Search Relevance | Score Boosting > Decay Functions > Boost Points Closer to User | documentation | true | Search Relevance > Score Boosting > Decay Functions > Boost Points Closer to User
An example of decay functions is to combine the score with how close a result is to a user.
Considering each point has an associated geo location, we can calculate the distance between the point and the request's location.
Assuming we ... | [
0.023171380162239075,
-0.031711600720882416,
0.002143919700756669,
-0.03629821911454201,
0.0501013919711113,
-0.016748612746596336,
0.027991432696580887,
0.03696196526288986,
0.0830022320151329,
0.0010655599180608988,
0.030645253136754036,
0.0182319488376379,
0.03310439735651016,
0.0407631... |
1605d33e-0a8a-5efe-b9dc-05b3d9fd643d | /documentation/tutorials-build-essentials/question-answering-langchain/ | Question Answering with LangChain and Qdrant | Why Use Qdrant for Question Answering with LangChain? | documentation | false | Question Answering with LangChain and Qdrant > Why Use Qdrant for Question Answering with LangChain?
It has been reported millions of times, but let's say it again. Modern LLMs, whether that's Claude, GPT, or any other chat model, still struggle to
generate factual statements if no context is provided. They have some ... | [
0.020110007375478745,
-0.022922776639461517,
-0.03364044427871704,
-0.030599165707826614,
0.04585324972867966,
-0.03700112923979759,
0.06665141135454178,
0.00875470507889986,
0.07781035453081131,
-0.0455130897462368,
0.014548211358487606,
-0.012876092456281185,
0.06359802186489105,
-0.0268... |
160791a3-8e56-5441-a354-0c152d2646d5 | /documentation/private-cloud/api-reference/ | API Reference | auth.qdrant.io/v1alpha1 | documentation | false | API Reference > auth.qdrant.io/v1alpha1
## Packages
- [auth.qdrant.io/v1alpha1](#authqdrantiov1alpha1)
- [qdrant.io/v1](#qdrantiov1)
Package v1alpha1 contains API Schema definitions for the qdrant.io v1alpha1 API group
### Resource Types
- [APIAuthentication](#apiauthentication)
#### APIAuthentication
APIAuthent... | [
0.026707839220762253,
-0.01946830190718174,
-0.051315758377313614,
-0.04137983173131943,
0.08981192111968994,
-0.066041961312294,
0.0465693436563015,
0.07804828137159348,
0.05321194604039192,
-0.037598978728055954,
0.04199960082769394,
0.00846045184880495,
0.0695730447769165,
-0.0263894647... |
1613e859-6414-585a-9983-c89ab2bd63ca | /documentation/search/search-relevance/ | Search Relevance | Relevance Feedback > Naive Strategy | documentation | false | Search Relevance > Relevance Feedback > Naive Strategy
For now, `naive` is the only available strategy.
Naive Strategy
$$
score = a * sim(query, candidate) + \sum_{pair \in pairs}{(confidence_{pair})^b * c * delta_{pair}} \\\\
$$
\begin{align}
\text{where} \\\\
confidence_{pair} &= relevance_{positive} - relevance_{... | [
0.026914577931165695,
-0.011298060417175293,
-0.046345461159944534,
-0.044211097061634064,
0.02172110229730606,
-0.04751717671751976,
0.050644610077142715,
0.012950673699378967,
0.041203614324331284,
-0.005793659016489983,
0.0350627675652504,
0.028186766430735588,
0.09562964737415314,
0.00... |
161b59f2-8071-5624-a97e-1cf109e25a23 | /documentation/tutorials-build-essentials/data-ingestion-beginners/ | S3 Ingestion | Next Steps | documentation | false | S3 Ingestion > Next Steps
You now have an ingestion pipeline with no framework between S3 and Qdrant. To extend it:
- Ingest other formats, such as PDFs or audio, by adding a reader function for each.
- Process new files only, instead of the whole bucket, by keeping track of the object keys or `ETag` values you have ... | [
0.035944949835538864,
-0.03417985141277313,
-0.03543878719210625,
-0.021943431347608566,
0.0621456503868103,
-0.036238498985767365,
0.039059869945049286,
0.028093915432691574,
0.04705844074487686,
-0.022104080766439438,
-0.008540831506252289,
0.035007916390895844,
0.0405610166490078,
-0.02... |
16200a8d-7d70-5e2f-aa08-7aa8cb7d69e0 | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Resident Memory Usage | documentation | true | Administration > Strict Mode > Maximum Resident Memory Usage
Deprecated as of v1.19.0. Use resource quotas to cap memory instead.
When a node is under memory pressure, new write operations can destabilize the cluster.
Setting `max_resident_memory_percent` rejects memory-consuming write operations (such as upsert and... | [
0.022793497890233994,
-0.027492903172969818,
0.001240682671777904,
-0.024459198117256165,
0.06489318609237671,
-0.04268686845898628,
0.045173801481723785,
0.0498211570084095,
0.05762748792767525,
-0.0386054553091526,
0.012794692069292068,
0.01149806845933199,
0.04313993081450462,
-0.059040... |
162bd44c-810f-5d62-928d-40872b9b6412 | /documentation/manage-data/storage/ | Storage | Vector storage > Configuring Memmap storage | documentation | true | Storage > Vector storage > Configuring Memmap storage
There are two ways to move vectors to the `cold` tier:
- Set the `memory` option for the vectors in the collection create API:
```python
from qdrant_client import QdrantClient, models
client.create_collection(
collection_name="{collection_name}",
vectors... | [
0.04625401273369789,
-0.03950944170355797,
-0.04040434584021568,
-0.03465406596660614,
0.04094463586807251,
-0.029837358742952347,
0.03331703320145607,
0.06009697541594505,
0.06510646641254425,
0.0009762526606209576,
-0.019207265228033066,
-0.022607585415244102,
0.03474971279501915,
-0.045... |
163009cc-d63f-597d-bc1e-d107fb473630 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 1. How Can You Get the Best Search Performance? | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 1. How Can You Get the Best Search Performance?
||
|:-:|
|**"Search got super slow after we added more vectors."**|
**Use Case:** A customer support startup saw intermittent latency spikes. Their index outgrew available memory, so disk fetches became frequent.... | [
0.018260285258293152,
-0.0686817616224289,
-0.05684436485171318,
-0.03273668512701988,
0.0611271858215332,
-0.03245558217167854,
0.016240399330854416,
-0.010937760584056377,
0.10058179497718811,
-0.02615289017558098,
-0.006934160832315683,
0.023048879578709602,
0.04960828274488449,
-0.0317... |
163c5add-2072-5e0b-8f8d-090cffa884be | /course/essentials/day-2/pitstop-project/ | Project: HNSW Performance Benchmarking | Optional: Go Further | course | false | Project: HNSW Performance Benchmarking > Optional: Go Further
* Test more granular parameters:
* **ef_construct** impact on recall & build time
* **hnsw_ef** per-query tuning by complexity
* Track memory usage differences (RAM/on-disk, payload indexes)
* Add accuracy metrics vs. a small labeled query set to see if ... | [
0.018298262730240822,
-0.04183141514658928,
-0.04606882855296135,
-0.017052527517080307,
0.045168615877628326,
-0.0468241423368454,
0.07446734607219696,
0.04090616852045059,
0.08160571753978729,
-0.02772979438304901,
0.02431062050163746,
0.024962829425930977,
0.06256649643182755,
-0.031015... |
165883f5-fba5-58da-a7a8-6fd2d9e377df | /documentation/fastembed/fastembed-splade/ | Working with SPLADE | Embed data | documentation | true | Working with SPLADE > Embed data
You need to define a list of documents to be embedded.
```python
documents: list[str] = [
"Chandrayaan-3 is India's third lunar mission",
"It aimed to land a rover on the Moon's surface - joining the US, China and Russia",
"The mission is a follow-up to Chandrayaan-2, whic... | [
0.008943548426032066,
-0.02127220667898655,
-0.050629135221242905,
-0.0736318901181221,
0.06894141435623169,
-0.05264865234494209,
0.0341256745159626,
0.04498949274420738,
0.04395356401801109,
-0.0075281900353729725,
0.020884035155177116,
0.0303763747215271,
0.06196495518088341,
-0.0233308... |
1658cb90-5b8f-5beb-b502-bcb56876ea61 | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | Sparse Neural Retrieval: As If Keyword-Based Retrievers Understood Meaning | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ > Sparse Neural Retrieval: As If Keyword-Based Retrievers Understood Meaning
Sooner or later, there should have been somebody who would say,
“*Wait, but what if I want something timeproof like BM25 but with semantic understanding?*” | [
0.035427678376436234,
-0.05366750806570053,
-0.021326681599020958,
-0.06817766278982162,
0.03951050341129303,
-0.057379912585020065,
0.045166678726673126,
0.011251755058765411,
0.07593443989753723,
0.01078026369214058,
0.04835322126746178,
0.02384878881275654,
0.08058267086744308,
-0.02250... |
16795392-6bdb-5030-9b8a-b537e3aa0568 | /documentation/embeddings/voyage/ | Voyage AI | Embed Documents | documentation | true | Voyage AI > Embed Documents
Set `input_type` to `document` for content you store. The vectors come back in input order, and each item of the API response carries the `index` of its input. These examples use that position as the point ID:
```python
documents = [
"Qdrant is a vector search engine.",
"Voyage AI ... | [
0.02178840897977352,
-0.05048740655183792,
-0.026453081518411636,
-0.06424299627542496,
0.059682734310626984,
-0.05504936724901199,
0.04703976958990097,
0.06823346018791199,
0.08083439618349075,
-0.047549452632665634,
0.029160553589463234,
0.04879118129611015,
0.008487115614116192,
-0.0222... |
1685b072-107f-583f-810d-deb963bdc4a2 | /documentation/data-management/airbyte/ | Airbyte | Prerequisites | documentation | false | Airbyte > Prerequisites
Before you start, make sure you have the following:
1. Airbyte instance, either [Open Source](https://airbyte.com/solutions/airbyte-open-source),
[Self-Managed](https://airbyte.com/solutions/airbyte-enterprise), or [Cloud](https://airbyte.com/solutions/airbyte-cloud).
2. Running instance of... | [
0.016255026683211327,
-0.04197806119918823,
-0.04175180941820145,
-0.05939672514796257,
0.06481746584177017,
-0.026054127141833305,
0.009935559704899788,
0.032781295478343964,
0.04050184413790703,
-0.02460521087050438,
0.03837478905916214,
-0.01264976430684328,
0.04953765124082565,
-0.0426... |
1695c821-93c9-5ba0-8031-187473c56548 | /documentation/embeddings/ollama/ | Ollama | Next Steps | documentation | false | Ollama > Next Steps
- Read the [Ollama embeddings guide](https://docs.ollama.com/capabilities/embeddings) and the [`/api/embed` reference](https://docs.ollama.com/api/embed).
- [Filter search results](/documentation/search/filtering/) by payload fields.
- [Combine Ollama vectors with sparse vectors](/documentation/sea... | [
0.05626817047595978,
-0.05044853687286377,
-0.04140010103583336,
-0.05930660292506218,
0.09849667549133301,
-0.015244570560753345,
0.0543631948530674,
0.03675590455532074,
0.0493142195045948,
-0.028760308399796486,
0.003613867564126849,
0.020328259095549583,
0.036773502826690674,
-0.010146... |
169d1069-8d08-5e34-a13d-05b4775b0e59 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Creating a sparse vector | article | true | Understanding SPLADE and Sparse Vectors > Creating a sparse vector
We'll explore two different ways to create a sparse vector. The higher performance way to create a sparse vector from dedicated document and query encoders. We'll look at a simpler approach -- here we will use the same model for both document and query... | [
0.0573958121240139,
-0.03943013772368431,
-0.0156241524964571,
-0.061421580612659454,
0.05920403078198433,
-0.026111457496881485,
0.05214207246899605,
0.06644762307405472,
0.052843157202005386,
-0.020485112443566322,
0.009767717681825161,
0.04293728619813919,
0.003501003375276923,
-0.00235... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.