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 |
|---|---|---|---|---|---|---|---|
e1773948-4299-5e2f-906d-290c348c3d3f | /documentation/tutorials-operations/large-scale-search/ | Large-Scale Search | Dataset | documentation | false | Large-Scale Search > Dataset
The dataset we will use is [LAION-400M](https://laion.ai/blog/laion-400-open-dataset/), a collection of approximately 400 million vectors obtained from
images extracted from a Common Crawl dataset. Each vector is 512-dimensional and generated using a [CLIP](https://openai.com/blog/clip/) m... | [
0.011434648185968399,
-0.003804323496297002,
-0.046233776956796646,
-0.02424018830060959,
0.08292867243289948,
-0.052378375083208084,
0.05261990427970886,
0.058640576899051666,
0.05022723227739334,
-0.038755401968955994,
0.02701209858059883,
0.021277058869600296,
0.04417372867465019,
-0.03... |
e19b41dd-3591-5b60-8b05-84d4d09d17cd | /course/essentials/day-7/tensorlake/ | Integrating with Tensorlake | TensorLake Knowledge Graph Integration > Advanced Query Capabilities | course | false | Integrating with Tensorlake > TensorLake Knowledge Graph Integration > Advanced Query Capabilities
The system supports multiple query types:
- **Simple Semantic Queries**: Basic vector similarity search without filtering
- **Filtered Queries**: Search by specific authors, conferences, or other metadata
- **Combined Q... | [
0.01374227274209261,
-0.05722047761082649,
-0.098248690366745,
0.01985318399965763,
0.07364753633737564,
-0.021723568439483643,
0.05909016355872154,
0.026441331952810287,
0.06192394718527794,
-0.03550172969698906,
0.029661566019058228,
0.013472499325871468,
0.06733939796686172,
-0.00228909... |
e1a2ca49-e074-575e-8370-78caf9967b7b | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Benchmarks > Oversampling and Rescoring | article | false | Scalar Quantization for Vector Search > Benchmarks > Oversampling and Rescoring
A distinctive feature of the Qdrant architecture is the ability to combine the search for quantized and original vectors in a single query.
This enables the best combination of speed, accuracy, and RAM usage.
Qdrant stores the original ve... | [
0.050371959805488586,
-0.031366389244794846,
-0.042061299085617065,
-0.023666616529226303,
0.0715855211019516,
-0.017593149095773697,
0.05071306228637695,
0.017644239589571953,
0.09852787852287292,
-0.057692091912031174,
0.01838412508368492,
-0.0015233648009598255,
0.046614836901426315,
-0... |
e1a67af5-978e-5c51-a215-4559d0258507 | /documentation/ops-configuration/running-with-gpu/ | Running with GPU | Configuration | documentation | true | Running with GPU > Configuration
Qdrant includes a number of configuration options to control GPU usage. The following options are available:
```yaml
gpu:
# Enable GPU indexing.
indexing: false
# Force half precision for `f32` values while indexing.
# `f16` conversion will take place
# only insid... | [
0.011612717062234879,
-0.05829635635018349,
-0.05228022113442421,
-0.05260074883699417,
0.05742856115102768,
-0.014629739336669445,
0.07013508677482605,
0.05942998453974724,
0.0858098566532135,
-0.026120662689208984,
0.06159447133541107,
0.0018494295654818416,
0.08794715255498886,
-0.03364... |
e1ad46fc-6f8c-54c4-86a6-6f72de94c7b4 | /documentation/tutorials-operations/large-scale-search/ | Large-Scale Search | Memory Usage > Which tier holds what | documentation | false | Large-Scale Search > Memory Usage > Which tier holds what
The two memory categories line up with the memory tiers:
| Structure | Tier in this tutorial | Estimated size | Shows up as |
|---|---|---|---|
| Original vectors (`FLOAT16`) | `cold` | 400Gb on disk | Neither. Read from disk only when rescoring |
| Quantized ... | [
0.04303554818034172,
-0.0057472907938063145,
-0.053721219301223755,
-0.017119746655225754,
0.05111543461680412,
-0.04752957820892334,
0.04440806806087494,
0.065500408411026,
0.09170061349868774,
-0.003737448249012232,
0.010730707086622715,
0.01239684410393238,
0.03126714378595352,
0.007130... |
e1d2812a-bacf-5d51-99c9-e5dc1f59eae3 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-1/ | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS | Connecting with NVIDIA VSS > Async Upload to VSS | documentation | true | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS > Connecting with NVIDIA VSS > Async Upload to VSS
Chunks are uploaded to VSS in parallel using async I/O:
```python
async def upload_to_vss(file_path: str | Path) -> Optional[str]:
"""Upload a single video file to NVIDIA VSS."""
file_p... | [
0.018271369859576225,
-0.05771244689822197,
-0.0744147002696991,
-0.04313395544886589,
0.08429846167564392,
-0.007065541110932827,
0.05135238543152809,
0.018713735044002533,
0.06890565156936646,
-0.03320104628801346,
0.017432114109396935,
0.021117597818374634,
0.039344288408756256,
-0.0193... |
e1dcf5b3-38f1-53e9-a916-52f9276bc622 | /course/beginners/module-6/measure-first/ | Measure First | course | false | Measure First
Module 6
Ranking changes are hard to judge by eye, because a worse results page still looks like a list of plausible documents. Measure what you have before you change anything.
A golden set pairs queries with the documents that should come back for them. It turns a ranking change into a number.
Sampl... | [
0.03610638529062271,
-0.04125314950942993,
-0.046158500015735626,
-0.010604697279632092,
0.06648274511098862,
-0.016460688784718513,
0.045179858803749084,
0.027904605492949486,
0.08426307141780853,
-0.04316939786076546,
-0.007594436407089233,
-0.011200027540326118,
0.06454675644636154,
-0.... | |
e2011273-525f-516f-b538-931f8b2b8a68 | /documentation/scaling/node-failure-recovery/ | Node Failure Recovery | Recreate a Node with Replicated Collections | documentation | false | Node Failure Recovery > Recreate a Node with Replicated Collections
If a node fails and it's impossible to recover it, you should exclude the dead node from the consensus and create a new node:
1. To exclude failed nodes from the consensus, use [remove peer](https://api.qdrant.tech/master/api-reference/distributed/re... | [
0.03593472018837929,
-0.029566409066319466,
-0.024053659290075302,
-0.05273725837469101,
0.10914621502161026,
-0.03797999396920204,
0.049022283405065536,
0.026669254526495934,
0.043517597019672394,
-0.05080114305019379,
0.02148621156811714,
0.04048316925764084,
0.04094715043902397,
-0.0446... |
e21862b6-7cfe-5599-bcdc-1059181c9993 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Customizing for Your Use Case > Setup | documentation | true | Relevance Feedback Retrieval in Qdrant > Customizing for Your Use Case > Setup
Install the aforementioned package (it will automatically install the Qdrant Client as its dependency):
```bash
pip install qdrant-relevance-feedback
```
We're going to use a [Qdrant Cloud Free Tier Cluster](https://qdrant.tech/documentat... | [
0.043573468923568726,
-0.005516976583749056,
-0.007762240711599588,
-0.058315347880125046,
0.06502591073513031,
-0.04876568913459778,
0.04839957505464554,
0.04958057031035423,
0.04184822738170624,
-0.002637082478031516,
0.017914509400725365,
0.016280582174658775,
0.07110665738582611,
-0.05... |
e2195a1c-fb3e-5c1d-aad5-09fef5d890a4 | /documentation/frameworks/honeyhive/ | HoneyHive | documentation | true | HoneyHive
[HoneyHive](https://www.honeyhive.ai/) is an AI evaluation and observability platform for Generative AI applications. HoneyHive’s platform gives developers enterprise-grade tools to debug complex retrieval pipelines, evaluate performance over large test suites, monitor usage in real-time, and manage prompts ... | [
0.03563600033521652,
-0.03740373253822327,
-0.04456878826022148,
-0.07503075897693634,
0.07550325989723206,
-0.038201816380023956,
0.09628795087337494,
0.01827717013657093,
0.0224553644657135,
-0.05651867762207985,
-0.0010049516567960382,
0.05433470755815506,
0.062236860394477844,
-0.01071... | |
e2273927-52e1-5ae3-81e2-7521448ff7da | /documentation/private-cloud/qdrant-cluster-management/ | Managing a Cluster | GPU support | documentation | true | Managing a Cluster > GPU support
Starting with Qdrant 1.13 and private-cloud version 1.6.1 you can create a cluster that uses GPUs to accelerate indexing.
As a prerequisite, you need to have a Kubernetes cluster with GPU support. You can check the [Kubernetes documentation](https://kubernetes.io/docs/tasks/manage-gpu... | [
0.021556859835982323,
-0.03362978249788284,
-0.0676167830824852,
-0.0013580353697761893,
0.048490386456251144,
-0.025841275230050087,
0.05834759399294853,
0.03244543448090553,
0.06575382500886917,
-0.029069291427731514,
0.054665401577949524,
0.022637348622083664,
0.051955725997686386,
-0.0... |
e2590bc3-a6b5-52cb-8cbd-3c7a97366870 | /documentation/tutorials-basics/search-beginners/ | Semantic Search 101 | 5. Query the Engine | documentation | true | Semantic Search 101 > 5. Query the Engine
Now that the data is stored in Qdrant, you can query it and receive semantically relevant results.
```python
hits = client.query_points(
collection_name=COLLECTION_NAME,
query=models.Document(
text="alien invasion",
model=EMBEDDING_MODEL
),
lim... | [
0.045720938593149185,
-0.03132261708378792,
-0.04811811074614525,
-0.030540095642209053,
0.06503283977508545,
-0.01831148937344551,
0.03144563362002373,
0.02331898920238018,
0.09084135293960571,
-0.04203936830163002,
0.04871305450797081,
0.026662971824407578,
0.05647658929228783,
-0.019306... |
e26719da-9811-5282-a75f-2d7602fa75b0 | /course/beginners/module-3/where-we-left-off/ | Where We Left Off | course | false | Where We Left Off
Module 3
In Module 2, you built a complete ingestion and retrieval pipeline: raw text, vector, store, top-K query. Dense retrieval handles meaning well. It gets shaky on the part of a query that has to be exact.
Here is a shoe catalog with two products one digit apart. Searching it dense-only for `... | [
0.056021496653556824,
-0.023616161197423935,
-0.06362716853618622,
-0.060920849442481995,
0.06390376389026642,
-0.030177317559719086,
0.0010517287300899625,
0.016503380611538887,
0.059985119849443436,
-0.0176992304623127,
0.033180564641952515,
0.03372717276215553,
0.04270242899656296,
-0.0... | |
e2abe3c0-de00-54c9-91f6-4bd8bb740687 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Conclusion | documentation | false | Relevance Feedback Retrieval in Qdrant > Conclusion
In this tutorial, we demonstrated how to use relevance feedback on text data to increase the relevance of results in your retrieval pipelines. Here's what to keep in mind:
- **Adaptable to your data** -- works on different modalities, not only text. You can do the s... | [
0.02941952459514141,
-0.0367204025387764,
-0.038873717188835144,
-0.07731147110462189,
0.044224195182323456,
-0.04001495614647865,
0.05654295161366463,
0.023345286026597023,
0.03739769756793976,
-0.005278785713016987,
-0.0006221873918548226,
0.018164843320846558,
0.09081222116947174,
-0.03... |
e2ad9715-a2e9-5dcc-a141-f28efe665503 | /documentation/security/ | Security | Authentication > Table of Access | documentation | false | Security > Authentication > Table of Access
| Action | manage | read-only | collection read-write | collection read-only |
|--------|--------|-----------|----------------------|-----------------------|
| get quotas | ✅ | ✅ | ❌ | ❌ |
| set quotas | ✅ | ❌ | ❌ | ❌ |
| get point | ✅ | ✅ | ✅ | ✅ |
| get points | ✅ | ✅ | ✅ ... | [
0.020945610478520393,
-0.03893999382853508,
-0.04507026448845863,
-0.0015424084849655628,
0.04010485112667084,
-0.030126146972179413,
0.028990061953663826,
0.05513645336031914,
0.04386802762746811,
-0.03857209160923958,
0.05837278440594673,
0.035973045974969864,
0.0304662324488163,
-0.0364... |
e2c56cb4-aed7-5131-b7c8-70713d63054b | /articles/predicting-weak-retrieval/ | Predicting Weak Retrieval Without an LLM | Find Your Signal | article | true | Predicting Weak Retrieval Without an LLM > Find Your Signal
The winning signal does not transfer, but the method does. On a calibration split, score each candidate by its separation:
```python
from sklearn.metrics import roc_auc_score
def separation(values, weak_labels):
auc = roc_auc_score(weak_labels, values)
... | [
0.029229624196887016,
-0.07346626371145248,
-0.03349105268716812,
-0.008862128481268883,
0.05325847864151001,
-0.008097391575574875,
0.04178526625037193,
0.025210032239556313,
0.035450078547000885,
-0.0012949134688824415,
0.018048835918307304,
0.003536487929522991,
0.03978399187326431,
-0.... |
e2dc61fc-6c54-5e21-b854-d474353fe77c | /documentation/embeddings/nvidia/ | NVIDIA | Embed Queries | documentation | true | NVIDIA > Embed Queries
Embed the query with the same model and `input_type` set to `query`. The model encodes passages and queries differently, and NVIDIA warns that using the wrong `input_type` causes large drops in retrieval accuracy.
```python
query_response = nvidia.embeddings.create(
model=MODEL,
input=[... | [
0.030748195946216583,
-0.06334744393825531,
-0.025369033217430115,
-0.0541372112929821,
0.059792302548885345,
-0.0191314946860075,
0.04238367825746536,
0.06313063949346542,
0.03538443148136139,
-0.0313834585249424,
0.0277407206594944,
0.017748596146702766,
0.027626318857073784,
-0.03762270... |
e307d717-c0b8-59cd-9d47-27f3f8119e49 | /documentation/frameworks/fifty-one/ | FiftyOne | documentation | true | FiftyOne
[FiftyOne](https://voxel51.com/) is an open-source toolkit designed to enhance computer vision workflows by optimizing dataset quality
and providing valuable insights about your models. FiftyOne 0.20, which includes a native integration with Qdrant, supporting workflows
like [image similarity search](https:... | [
0.08117324858903885,
-0.09452103823423386,
-0.08624143898487091,
-0.014738482423126698,
0.06816409528255463,
-0.017309395596385002,
0.0680612251162529,
0.03687545657157898,
0.07464373111724854,
-0.053206104785203934,
0.06329545378684998,
0.020313115790486336,
0.027766628190875053,
-0.01438... | |
e31dfe7b-1625-512c-9f2b-9c04eb343e70 | /documentation/search-precision/automate-filtering-with-llms/ | LLM-Powered Filter Automation | Using Instructor to generate Qdrant filters > Testing the LLM output | documentation | true | LLM-Powered Filter Automation > Using Instructor to generate Qdrant filters > Testing the LLM output
If you plan to automate filtering, it makes sense to run
some tests to see how well LLMs perform. Especially edge cases, like queries that cannot be expressed as filters.
Generally, giving model some more guidance on ... | [
0.03715645521879196,
-0.06347303092479706,
-0.06556292623281479,
-0.04637158662080765,
0.05789435654878616,
-0.022866975516080856,
0.05642494931817055,
0.016198577359318733,
0.06756923347711563,
-0.02652769349515438,
0.04835264012217522,
0.0019993989262729883,
0.06707039475440979,
-0.02893... |
e32553ae-d5a3-518a-a0fd-4d79a56d9e79 | /documentation/ops-configuration/usage-statistics/ | Usage Statistics | Deactivate usage statistics | documentation | false | Usage Statistics > Deactivate usage statistics
You can deactivate usage statistics by:
- setting the `QDRANT__TELEMETRY_DISABLED` environment variable to `true`
- setting the config option `telemetry_disabled` to `true` in the `config/production.yaml` or `config/config.yaml` files
- using cli option `--disable-teleme... | [
0.05016351118683815,
-0.00861591100692749,
-0.0015870108036324382,
-0.015667565166950226,
0.013316136784851551,
-0.00747658172622323,
0.003249857109040022,
0.044379618018865585,
0.054422881454229355,
-0.01653187721967697,
0.06018480658531189,
0.01752285659313202,
0.1012062281370163,
-0.023... |
e33a2e0a-4c60-5ee8-a320-637d120c86a8 | /documentation/ | Documentation | Deploy | documentation | false | Documentation > Deploy
- [Deploy Overview](/documentation/deploy-intro/index.md) — Compare all Qdrant deployment options: Managed Cloud, Hybrid Cloud, Private Cloud, and self-hosted.
- [Installation](/documentation/installation/index.md) — Install Qdrant via Docker, Kubernetes, or binary on Linux, macOS, or Windows.
-... | [
0.008245916105806828,
-0.04747089371085167,
-0.07103957235813141,
-0.034803882241249084,
0.0810367539525032,
-0.009486199356615543,
0.04955120384693146,
0.025465108454227448,
0.06041780859231949,
-0.0386202298104763,
0.029208578169345856,
0.002330127405002713,
0.022256825119256973,
-0.0563... |
e33e98ff-29d5-51d7-b81d-2c6973cf2d37 | /documentation/migrate-to-qdrant/from-faiss/ | From FAISS | Run the Migration | documentation | true | From FAISS > Run the Migration
```bash
docker run --net=host --rm -it \
-v /path/to/your/index:/data \
registry.cloud.qdrant.io/library/qdrant-migration faiss \
--faiss.index-path '/data/your-index.index' \
--qdrant.url 'https://your-instance.cloud.qdrant.io:6334' \
--qdrant.api-key 'your-qdrant-ap... | [
0.04637622833251953,
-0.0418110266327858,
0.002677452750504017,
-0.040695954114198685,
0.06350453943014145,
-0.05540137737989426,
0.03562158718705177,
0.021660849452018738,
0.05357982963323593,
-0.044951826333999634,
0.044561538845300674,
-0.01479951199144125,
0.03888249769806862,
-0.02959... |
e3774ecf-bd98-577b-8eec-9205570603ea | /documentation/search/search/ | Search | Random Sampling | documentation | true | Search > Random Sampling
*Available as of v1.11.0*
In some cases it might be useful to retrieve a random sample of points from the collection. This can be useful for debugging, testing, or for providing entry points for exploration.
Random sampling API is a part of [Universal Query API](#query-api) and can be used i... | [
0.027410006150603294,
-0.04961279779672623,
-0.00882332306355238,
-0.08981896191835403,
0.0729638859629631,
-0.017574217170476913,
0.07583078742027283,
0.03920435160398483,
0.10055524110794067,
-0.04915710166096687,
0.057802002876996994,
0.05434524640440941,
0.07801930606365204,
-0.0140738... |
e3afe048-a17d-52e3-a70a-e63e62969349 | /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.0004213642387185246,
-0.02755921147763729,
-0.020366640761494637,
-0.00035916612250730395,
0.06468190252780914,
-0.0514407679438591,
0.0713372454047203,
0.06264881044626236,
0.07497364282608032,
-0.03686412796378136,
0.015750234946608543,
-0.006708104163408279,
0.04027891531586647,
-0.0... |
e3be6a6d-17da-5529-855b-1d19417dcea0 | /course/multi-vector-search/module-1/late-interaction-basics/ | Late Interaction Basics | Understanding the Alternatives | course | true | Late Interaction Basics > Understanding the Alternatives
Before diving into late interaction, let's establish what we mean by "interaction."
In search systems, **interaction** refers to when and how the query and document representations influence each other. Do they interact during encoding, or only during compariso... | [
0.030104227364063263,
-0.04774230718612671,
-0.05662313848733902,
-0.025742366909980774,
0.05726013705134392,
-0.03224736824631691,
0.0201859250664711,
0.008824381977319717,
0.08345076441764832,
-0.007712926249951124,
0.025168079882860184,
-0.00042852063779719174,
0.04782411828637123,
-0.0... |
e3ceac67-5723-5f3c-85c8-43083f703a53 | /documentation/migrate-to-qdrant/from-mongodb/ | From MongoDB | Gotchas | documentation | false | From MongoDB > Gotchas
- **Named vectors:** Every vector field becomes a named vector with the field's name, even when there is only one. Pre-create the collection with a named vector for each field.
## Next Steps
After migration, verify your data arrived correctly with the [Migration Verification Guide](/documentat... | [
0.01796662248671055,
-0.06361265480518341,
-0.062308404594659805,
-0.044999100267887115,
0.030670782551169395,
-0.03920166566967964,
0.04072071984410286,
0.047659050673246384,
0.044561613351106644,
-0.030060941353440285,
0.022505082190036774,
0.040206607431173325,
0.04289626702666283,
-0.0... |
e4009a0c-ea57-5316-8341-d12cd887cd1c | /documentation/examples/multitenancy/ | Multitenancy with Qdrant | Setting up the pipeline > Connecting to Qdrant and loading the embedding model | documentation | true | Multitenancy with Qdrant > Setting up the pipeline > Connecting to Qdrant and loading the embedding model
Any semantic search application requires a way to convert text into vectors: an embedding model. We'll use
[BAAI/bge-small-en-v1.5](https://huggingface.co/BAAI/bge-small-en-v1.5), which runs locally through FastEm... | [
0.046549297869205475,
-0.052391376346349716,
-0.031591661274433136,
-0.05625682696700096,
0.05843619257211685,
-0.05773409083485603,
0.05047060176730156,
0.023203982040286064,
0.028585372492671013,
-0.03405173122882843,
0.039296265691518784,
0.022257409989833832,
0.07468311488628387,
-0.05... |
e40558de-2f22-5d22-a21b-5a970e9186ef | /documentation/manage-data/quantization/ | Quantization | Setting Up Quantization in Qdrant > Setting Up Binary Quantization | documentation | true | Quantization > Setting Up Quantization in Qdrant > Setting Up Binary Quantization
To enable binary quantization, you need to specify the quantization parameters in the `quantization_config` section of the collection configuration.
When enabling binary quantization on an existing collection, use a PATCH request or the... | [
0.041755519807338715,
-0.06862164288759232,
-0.023467889055609703,
-0.028142843395471573,
0.034592632204294205,
-0.046767305582761765,
-0.0019363597966730595,
0.07555083185434341,
0.09312466531991959,
-0.00805983692407608,
0.025998147204518318,
0.025562088936567307,
0.04625329747796059,
-0... |
e40b5f80-3414-52ca-8db8-5a26bc505de1 | /course/essentials/day-0/pitstop-project/ | Project: Building Your First Vector Search System | Setup | course | false | Project: Building Your First Vector Search System > Setup
### Prerequisites
- Qdrant Cloud cluster (URL + API key)
- Python 3.9+ (or Colab)
- Required packages: `qdrant-client`.
### Models
- None. We will create vectors by hand.
### Dataset
- None. We will create our own data points.
Before creating data, decide... | [
0.04796412214636803,
-0.04283221811056137,
-0.054640308022499084,
-0.016393626108765602,
0.08318320661783218,
-0.04839472472667694,
0.0644303560256958,
0.030505334958434105,
0.07812821120023727,
-0.031959082931280136,
0.02953944355249405,
-0.0011583976447582245,
0.059613801538944244,
-0.02... |
e4161e1a-e1a0-57cd-bbcc-873f7cffed44 | /documentation/migration-guidance/diagnosing-discrepancies/ | Diagnosing Discrepancies | Configuration-Level Issues > Vector Normalization | documentation | true | Diagnosing Discrepancies > Configuration-Level Issues > Vector Normalization
Cosine similarity and dot product produce identical rankings when vectors are unit-normalized (L2 norm = 1.0). If your source system assumed normalized vectors and you switch to dot product (or vice versa) during migration, results will diffe... | [
0.07671376317739487,
-0.08264218270778656,
-0.065911203622818,
-0.05013903230428696,
0.03643834963440895,
-0.007129729725420475,
0.09855630248785019,
0.05070807412266731,
0.07571408152580261,
-0.0076011852361261845,
0.03368040919303894,
0.022535055875778198,
0.0218063872307539,
0.002217668... |
e44abb75-fb1e-5fe6-9c45-4cbd90b31999 | /articles/distance-based-exploration/ | Data Exploration with Qdrant's Distance Matrix API | Graphs | article | false | Data Exploration with Qdrant's Distance Matrix API > Graphs
Clustering and dimensionality reduction both aim to provide a more transparent overview of the data.
However, they share a common characteristic: they require a training step before the results can be visualized.
This also means that new data points require ... | [
0.017382292076945305,
-0.029021266847848892,
-0.05981025472283363,
-0.008189243264496326,
0.09085388481616974,
-0.041049689054489136,
0.050411488860845566,
0.05526601895689964,
0.04002584517002106,
-0.02738342620432377,
0.04530666396021843,
0.0521661713719368,
0.08297569304704666,
-0.01203... |
e45eb314-c099-59df-9e54-8df0539bdc60 | /course/beginners/module-3/module-overview/ | Module Overview | course | false | Module Overview
Module 3
Understand dense versus sparse retrieval, their strengths, and how a hybrid approach can combine them.
**Follow-along code**: [Module 3 notebook](https://github.com/qdrant/examples/blob/master/course/beginners/Module3.ipynb)
#### Overview
> Module 2 showed you where your data lives and how... | [
0.0544145442545414,
-0.0374017134308815,
-0.06170704960823059,
-0.034155815839767456,
0.07005911320447922,
-0.04379066824913025,
0.04393885284662247,
0.02858007699251175,
0.08182404190301895,
-0.017887333407998085,
0.020770469680428505,
0.04010360315442085,
0.0560983344912529,
-0.022375974... | |
e465d27d-5454-5d9f-8327-32b25e69f34c | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | Agentic RAG: Combining RAG with Agents | article | false | What is Agentic RAG? Building Agents with Qdrant > Agentic RAG: Combining RAG with Agents
However, routing is just the beginning. Agents can be much more complex, and extreme forms of agents can have complete
freedom to act. In such cases, the agent is given a set of tools and can autonomously decide which ones to use... | [
-0.012078800238668919,
-0.047609422355890274,
-0.07811463624238968,
-0.013165608048439026,
0.10203990340232849,
-0.08130288869142532,
0.08108290284872055,
0.054112061858177185,
0.06938908994197845,
-0.009562009945511818,
0.031234009191393852,
0.02377930097281933,
0.04198097065091133,
-0.03... |
e472c910-638c-5870-9b05-1bc03ba864c4 | /documentation/quickstart/ | Local Quickstart | Add a filter | documentation | true | Local Quickstart > Add a filter
We can narrow down the results further by filtering by payload. Let's find the closest results that include "London".
```python
from qdrant_client.models import Filter, FieldCondition, MatchValue
search_result = client.query_points(
collection_name="test_collection",
query=[0.... | [
0.04491056874394417,
-0.03187048062682152,
-0.046243950724601746,
-0.0053376685827970505,
0.07045728713274002,
-0.02437354438006878,
0.05374467745423317,
0.016783520579338074,
0.0852339118719101,
-0.05274954065680504,
0.04767557978630066,
0.031162409111857414,
0.034688614308834076,
-0.0084... |
e4acfd6a-1135-5b66-8e90-f7d851b25d11 | /documentation/manage-data/indexing/ | Indexing | Vector Index > Disable the Creation of Extra Edges for Payload Fields | documentation | true | Indexing > Vector Index > Disable the Creation of Extra Edges for Payload Fields
*Available as of v1.17.0*
Not all payload indices may be intended for use with dense vector search. For example, when a collection contains both dense and sparse vectors, some payload fields may only be used to filter sparse vector searc... | [
0.05375140905380249,
-0.026853665709495544,
-0.04823388159275055,
-0.0299474336206913,
0.08383981138467789,
-0.06440585106611252,
0.0168545451015234,
0.0392119474709034,
0.06912162899971008,
-0.05932297557592392,
0.062922403216362,
0.04493745043873787,
0.056579213589429855,
0.0154860327020... |
e4ba7120-24d1-590c-aa63-206afd5e22be | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Takeaways | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Takeaways
This article describes a preliminary experiment. The model behind these tables trains 2,398 concepts out of a vocabulary of roughly 12,000, on at most 800 sentences per concept and language taken from a small slice of Wikipedia.
Within t... | [
0.04172772914171219,
-0.02991200052201748,
-0.026305418461561203,
-0.05448974296450615,
0.09205597639083862,
-0.04516538232564926,
0.04566536843776703,
0.062283314764499664,
0.05916603282094002,
-0.04322117567062378,
0.017467984929680824,
0.04097779095172882,
0.06750012189149857,
-0.048680... |
e4cc2fe0-d5d9-5fb7-b377-9ba4f1f7f18f | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > StorageClass | documentation | false | API Reference > qdrant.io/v1 > Resource Types > StorageClass
_Appears in:_
- [QdrantCloudRegionStatus](#qdrantcloudregionstatus)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `name` _string_ | Name specifies the name of the storage class | | |
| `default` _boolean_ | Default specifies w... | [
0.03622734546661377,
-0.015537804923951626,
-0.00033595942659303546,
-0.06899029016494751,
0.056901637464761734,
-0.0423632487654686,
0.058185409754514694,
0.06734766066074371,
0.0545555017888546,
-0.022559408098459244,
0.025815775617957115,
0.014059053733944893,
0.04664747416973114,
-0.00... |
e4d172ab-02e6-53b6-97c7-a9c75914252c | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Training miniCOIL > Architecture and Training Objective | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Training miniCOIL > Architecture and Training Objective
Let's continue dealing with *"bats"*.
We have a training pool of sentences containing the word *"bat"* in different meanings. Using a dense encoder of choice, we get a contextualized embedding of *"bat"* ... | [
0.0512361153960228,
-0.051162805408239365,
-0.044412195682525635,
-0.058239858597517014,
0.050446271896362305,
-0.030072148889303207,
0.038435257971286774,
0.0395590141415596,
0.03889337182044983,
-0.03993036597967148,
0.02939058654010296,
0.009253301657736301,
0.0815272331237793,
-0.03162... |
e4d1dffb-c40c-564f-87c7-3a9224aef6a7 | /documentation/cloud/create-cluster/ | Create a Cluster | Creating a Production-Ready Cluster | documentation | false | Create a Cluster > Creating a Production-Ready Cluster
**Disk Speed (AWS only)**
We recommend the **Balanced** tier for disks >= 32 GiB, and the **Performance** tier for disks >= 256 GiB.
**GPUs (AWS only)**
If you have a write-heavy workload, you can add a GPU to each node to optimize indexing performance. See [**... | [
-0.001625840668566525,
-0.016178438439965248,
-0.08515045046806335,
-0.03725583106279373,
0.053451359272003174,
-0.020701175555586815,
0.02837269753217697,
0.05142499879002571,
0.09857971221208572,
-0.05338854715228081,
0.0476178340613842,
0.019306395202875137,
0.044545259326696396,
-0.059... |
e4d56fdf-3c71-500d-8333-fbacb50e1892 | /documentation/ops-configuration/quotas/ | Resource Quotas | Configuring Quotas > When Nodes Have Different Quotas | documentation | false | Resource Quotas > Configuring Quotas > When Nodes Have Different Quotas
Each node resolves its own quota, and Qdrant neither compares them across peers nor warns you when they differ. Enforcement is per node: a node that reached the limit rejects updates to the replicas it holds. When a shard is replicated elsewhere, ... | [
0.0383065901696682,
-0.05478084459900856,
-0.05025043711066246,
-0.069655641913414,
0.041561558842659,
-0.014401084743440151,
0.09177122265100479,
0.06633419543504715,
0.08256283402442932,
-0.031387992203235626,
0.02077462337911129,
0.020431090146303177,
0.05769377201795578,
-0.03513450175... |
e50f6929-3656-57bb-b3d6-ed02b7578c32 | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | Did we Solve the Vocabulary Mismatch Yet? > External Document Expansion > External Document Expansion with Term Independent Likelihood MODel (TILDE) | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ > Did we Solve the Vocabulary Mismatch Yet? > External Document Expansion > External Document Expansion with Term Independent Likelihood MODel (TILDE)
[`Term Independent Likelihood MODel (TILDE)`](https://github.com/ielab/TILDE) is an external expansion method th... | [
0.05970001593232155,
-0.03273551166057587,
-0.05680950731039047,
-0.02744714729487896,
0.07281702756881714,
-0.028493434190750122,
0.059028204530477524,
0.019958550110459328,
0.09470654278993607,
-0.03259684517979622,
0.04431157559156418,
0.03332200273871422,
-0.0004838682652916759,
-0.044... |
e5281501-42b0-5082-9623-9204d33fd8f4 | /course/multi-vector-search/module-0/qdrant-setup/ | Qdrant Setup | Verifying Your Setup | course | false | Qdrant Setup > Verifying Your Setup
Open the Qdrant Web UI:
- **Cloud users**: Click **Cluster UI** in the top-right corner of your cluster dashboard
- **Local users**: Navigate to `http://localhost:6333/dashboard`
If the Web UI loads and you can see the **Collections** tab, your setup is complete. In the next lesson... | [
0.06592225283384323,
-0.049245685338974,
0.009421253576874733,
-0.020869765430688858,
0.05676361545920372,
-0.028544269502162933,
0.06752604991197586,
0.04067615419626236,
0.04130206257104874,
-0.04315045848488808,
0.028698861598968506,
0.03267888352274895,
0.08410631865262985,
-0.03724899... |
e53a6d38-ef22-57ef-8fd8-6c88d6d5a8be | /course/essentials/day-7/camel/ | Integrating with Camel AI | Resources | course | false | Integrating with Camel AI > Resources
- [CAMEL Qdrant Integration](https://docs.camel-ai.org/cookbooks/applications/customer_service_Discord_bot_with_agentic_RAG#integrating-qdrant-for-large-files-to-build-a-more-powerful-discord-bot):
Official CAMEL documentation for integrating Qdrant with Discord bots and agent... | [
0.04089215025305748,
-0.034921981394290924,
-0.0507173016667366,
-0.02722717821598053,
0.0641547441482544,
-0.02808147668838501,
0.055422764271497726,
0.03129412978887558,
0.029619472101330757,
-0.016017483547329903,
0.06764712184667587,
-0.03650906682014465,
0.04531284049153328,
-0.043105... |
e544b03e-9839-5611-9276-061e2fa70efb | /course/multi-vector-search/module-3/multi-stage-retrieval/ | Multi-Stage Retrieval with Universal Query API | Advanced Multi-Stage Patterns | course | true | Multi-Stage Retrieval with Universal Query API > Advanced Multi-Stage Patterns
Multi-stage retrieval isn't limited to just two stages. You can chain multiple prefetch operations for three or more stages by nesting prefetch operations.
### Combining Multiple Weak Retrievers
You can also use multiple retrieval methods... | [
-0.002684888895601034,
-0.059795621782541275,
0.002523630391806364,
-0.020831391215324402,
0.06830133497714996,
-0.02890528179705143,
0.03773174062371254,
0.0326739102602005,
0.08613322675228119,
-0.02675803005695343,
0.01808317005634308,
0.03603266179561615,
0.052673038095235825,
-0.03247... |
e54be96c-d5eb-5054-be8a-d912a54c2624 | /documentation/tutorials-operations/scaling-and-monitoring-pods/ | Scaling and Monitoring Hybrid Cloud | Next Steps | documentation | false | Scaling and Monitoring Hybrid Cloud > Next Steps
You scaled CPU, memory, and disk independently and saw why only the first two restart the pod, read your cluster's real resource reservation, and know which metrics to check before scaling. See the [Hybrid Cloud cluster creation guide](/documentation/hybrid-cloud/hybrid... | [
0.030231283977627754,
0.023136252537369728,
-0.02746698074042797,
-0.03962469846010208,
0.06094789877533913,
-0.02187049761414528,
0.0384201817214489,
0.031743478029966354,
0.06264922022819519,
-0.0418565534055233,
0.018352940678596497,
-0.0032226634211838245,
0.06838203966617584,
0.002690... |
e55802b5-9882-596d-8865-0c201feffcf4 | /documentation/migration-guidance/diagnosing-discrepancies/ | Diagnosing Discrepancies | Data-Level Issues | documentation | true | Diagnosing Discrepancies > Data-Level Issues
### Partial Migration Failures
The most common data-level issue: a batch upload timed out or errored, and the migration script didn't retry.
```py
# Find missing IDs by comparing source and Qdrant
all_ids = set()
offset = None
while True:
records, offset = client.scro... | [
0.046387284994125366,
-0.043033480644226074,
-0.04497302696108818,
-0.04224951192736626,
0.048005178570747375,
-0.05681901052594185,
0.01693548820912838,
0.06499019265174866,
0.058707140386104584,
-0.04585174098610878,
0.0215368140488863,
0.0269304346293211,
0.05044375732541084,
-0.0321609... |
e55b2f1d-6675-53c2-8eca-fc2cc441ed9f | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Collections > How many collections can I create? | documentation | false | Qdrant Fundamentals > Collections > How many collections can I create?
As many as you want, but be aware that each collection requires additional resources.
It is _highly_ recommended not to create many small collections, as it will lead to significant resource consumption overhead.
We consider creating a collection ... | [
-0.017517684027552605,
0.0015759804518893361,
-0.028714755550026894,
-0.0487050861120224,
0.04673922434449196,
-0.0732722356915474,
0.025056036189198494,
0.06855539977550507,
0.10782607644796371,
-0.052112940698862076,
0.012958946637809277,
0.03766603395342827,
0.09392800182104111,
-0.0483... |
e5673a44-61fa-5bff-88e4-33f56743a1ff | /documentation/scaling/distributed_deployment/ | Distributed Deployment | documentation | false | Distributed Deployment
*Available since Qdrant v0.8.0*
Qdrant supports a distributed deployment mode.
In this mode, multiple Qdrant services communicate with each other to distribute the data across the peers to extend the storage capabilities and increase stability. | [
0.011199005879461765,
-0.018412046134471893,
-0.04224236682057381,
-0.046512264758348465,
0.06399031728506088,
-0.03843342885375023,
0.08159252256155014,
0.032472312450408936,
0.0870402455329895,
0.01530277356505394,
0.04856981337070465,
-0.0031299551483243704,
0.032208118587732315,
-0.024... | |
e5702db6-21a8-5cf9-b8b9-afa2f7a2c635 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Customizing for Your Use Case > Setup > Plugging in Collection, Retriever and Feedback Model | documentation | true | Relevance Feedback Retrieval in Qdrant > Customizing for Your Use Case > Setup > Plugging in Collection, Retriever and Feedback Model
Now we have everything in place: retriever, collection, feedback model.
```python
from qdrant_relevance_feedback import RelevanceFeedback
relevance_feedback = RelevanceFeedback(
... | [
0.03784980624914169,
-0.012471203692257404,
-0.0212705098092556,
-0.0766216591000557,
0.060948994010686874,
-0.04088766500353813,
0.0422733835875988,
0.04576624557375908,
0.03345474600791931,
0.005204087123274803,
0.01719316467642784,
0.039982348680496216,
0.11122788488864899,
-0.037878699... |
e582492d-e19b-5a4f-bbbd-1852759970f4 | /documentation/tutorials-search-engineering/slicing-filter/ | Deterministic Collection Slicing | Concurrent Scrolling Across Workers | documentation | true | Deterministic Collection Slicing > Concurrent Scrolling Across Workers
The main use case is splitting a full scroll into `N` independent, non-overlapping scrolls, one per worker. Each worker only needs its own `index`, and since the slices don't overlap, the requests have nothing to coordinate on and can run concurren... | [
0.014193910174071789,
0.002225689124315977,
-0.07612420618534088,
-0.00019622915715444833,
0.049956973642110825,
-0.009167869575321674,
0.05308310687541962,
0.029594071209430695,
0.048746414482593536,
0.008800551295280457,
0.0023778730537742376,
0.0486442968249321,
0.06179114431142807,
0.0... |
e5832a10-53eb-5917-b36d-c2bc2bb4b043 | /documentation/cloud-rbac/permission-reference/ | Permission Reference | Account Management | documentation | false | Permission Reference > Account Management
Permissions for managing user accounts.
| Permission | Description |
|------------|------------|
| `read:account` | View account details that the user is a part of. |
| `write:account` | Modify account details such as: - Editing the account name - Setting an account as defaul... | [
0.019288716837763786,
-0.02409692294895649,
-0.0874398797750473,
-0.04760902374982834,
0.03713248670101166,
-0.012278402224183083,
-0.015315867029130459,
0.06052635982632637,
0.06704395264387131,
-0.021170398220419884,
0.021733520552515984,
0.011040139943361282,
0.08005344867706299,
-0.051... |
e589e30b-47ce-5df6-a239-37fb908042b6 | /course/multi-vector-search/module-1/late-interaction-basics/ | Late Interaction Basics | Understanding the Alternatives > The Gap | course | false | Late Interaction Basics > Understanding the Alternatives > The Gap
We need an approach that combines the best of both worlds: the scalability of pre-computed single-vector representations and the fine-grained matching capability of cross-encoders. | [
0.011572111397981644,
-0.04055429622530937,
-0.05307351425290108,
-0.07509740442037582,
0.07486869394779205,
-0.07064629346132278,
0.042723558843135834,
0.024320654571056366,
0.06643415987491608,
0.009284252300858498,
0.030071984976530075,
-0.00608650129288435,
0.09084668755531311,
-0.0515... |
e5abd650-ac81-5582-97cc-a09aeae1d0c4 | /documentation/production-operations/access-control/ | Data Privacy with Qdrant's Role-Based Access Control (RBAC) | Qdrant Hybrid Cloud and Data Sovereignty | documentation | false | Data Privacy with Qdrant's Role-Based Access Control (RBAC) > Qdrant Hybrid Cloud and Data Sovereignty
Data governance varies by country, especially for global organizations dealing with different regulations on data privacy, security, and access. This often necessitates deploying infrastructure within specific geogra... | [
0.044941212981939316,
0.015598174184560776,
-0.07066139578819275,
-0.06170211732387543,
0.04086337238550186,
-0.03780551999807358,
0.12903925776481628,
0.04672810062766075,
0.0630604475736618,
-0.029927674680948257,
0.025113804265856743,
0.025806723162531853,
0.06331218034029007,
-0.007283... |
e5e1f2b6-c473-50fa-b24d-9113f8ada7f9 | /documentation/scaling/consistency-guarantees/ | Consistency Guarantees | Write Ordering | documentation | true | Consistency Guarantees > Write Ordering
Write `ordering` can be specified for any write request to serialize it through a single "leader" node,
which ensures that all write operations (issued with the same `ordering`) are performed and observed
sequentially.
- `weak` _(default)_ ordering does not provide any addition... | [
0.008934739045798779,
-0.07454164326190948,
-0.0796038806438446,
-0.00294708926230669,
0.054704200476408005,
-0.040170617401599884,
0.05723840370774269,
0.04300902038812637,
0.028554504737257957,
0.0028150351718068123,
0.023968251422047615,
0.025199947878718376,
0.028519518673419952,
-0.01... |
e5e35961-a8ee-505b-a7ae-7634ba8d9b24 | /documentation/manage-data/quantization/ | Quantization | Setting Up Quantization in Qdrant > Setting Up Product Quantization | documentation | true | Quantization > Setting Up Quantization in Qdrant > Setting Up Product Quantization
To enable product quantization, you need to specify the quantization parameters in the `quantization_config` section of the collection configuration.
When enabling product quantization on an existing collection, use a PATCH request or ... | [
0.04399348795413971,
-0.07243303954601288,
-0.021467121317982674,
-0.04198893532156944,
0.054430246353149414,
-0.03359533101320267,
0.019223229959607124,
0.05302128195762634,
0.11883525550365448,
-0.028977693989872932,
0.022183913737535477,
0.032879263162612915,
0.07899722456932068,
-0.055... |
e63e8b74-368f-5ca5-b29a-a80d6c8baa4a | /documentation/manage-data/multitenancy/ | Multitenancy | User-Defined Sharding | documentation | true | Multitenancy > User-Defined Sharding
*Available as of v1.7.0*
Instead of filtering tenants by a payload field, another way to separate tenants is to give each tenant its own dedicated shard. Qdrant lets you specify the shard for each point individually, so operations for a tenant only ever touch that tenant's shard. ... | [
0.02383740246295929,
-0.019056713208556175,
-0.04677708446979523,
-0.006869316101074219,
0.05014755204319954,
-0.05079927667975426,
0.051413293927907944,
0.035311225801706314,
0.07125876843929291,
-0.022684549912810326,
0.0304946918040514,
0.029720939695835114,
0.05624273791909218,
-0.0122... |
e6480b7f-bea1-57fc-81ae-5414bd710e93 | /documentation/production-checklist/ | Production Checklist | 4. Storage and Hardware | documentation | false | Production Checklist > 4. Storage and Hardware
Right-size your RAM, disk type, and storage mode. These decisions are difficult to change once you're in production.
- **Choose a [memory tier](/documentation/ops-configuration/memory-tiers/) for your vectors.**
`cached` gives maximum speed, but RAM becomes a bottleneck ... | [
0.020533287897706032,
-0.05634418874979019,
-0.05725916102528572,
-0.036116115748882294,
0.05741338059306145,
-0.014409856870770454,
0.03919136896729469,
0.012468996457755566,
0.09854103624820709,
-0.014368883334100246,
-0.0004268271732144058,
0.010068499483168125,
0.036019861698150635,
-0... |
e65f4a45-59a8-599f-855d-ff8ea7bc669a | /course/essentials/day-4/pitstop-project/ | Project: Quantization Performance Optimization | What You'll Build | course | false | Project: Quantization Performance Optimization > What You'll Build
A quantization-optimized search system that demonstrates:
- **Performance comparison**: Before and after quantization metrics
- **Method evaluation**: Testing scalar and binary quantization on your data
- **Accuracy recovery**: Implementing oversampli... | [
0.03948650881648064,
-0.026909690350294113,
-0.036277465522289276,
-0.02730630710721016,
0.08738899230957031,
-0.02762141451239586,
0.04653485491871834,
0.0031549723353236914,
0.08639951795339584,
-0.057202547788619995,
0.02629624865949154,
0.0035444314125925303,
0.06388120353221893,
-0.05... |
e665aa99-4fea-59ac-8b5c-ecd589649425 | /documentation/production-operations/predictable-search-latency/ | Configure Qdrant's Optimizer for Predictable Search Latency | How We Measured It | documentation | false | Configure Qdrant's Optimizer for Predictable Search Latency > How We Measured It
Each run followed the same three stages, shown in the diagram as a timeline from the last point uploaded to a settled baseline:
 — Create collections, insert and update points and payloads, configure vector indexes, quantization, and multitenancy.
- [Search](/documentation/search/index.md) — Similarity search, filtering, hybrid and multimodal queries, multi-stage pipel... | [
0.046789444983005524,
-0.0333651527762413,
-0.075095996260643,
-0.024360977113246918,
0.06164025515317917,
-0.03340907022356987,
0.09521518647670746,
0.04495430737733841,
0.06095574051141739,
-0.027606066316366196,
0.034206170588731766,
0.029687082394957542,
0.05019497871398926,
-0.0205529... |
e675ec12-b355-5593-9f6b-e70b3e297a41 | /articles/neural-search-tutorial/ | Neural Search 101: A Complete Guide and Step-by-Step Tutorial | Step-by-step neural search tutorial using Qdrant > Step 2: Incorporate a Vector search engine | article | true | Neural Search 101: A Complete Guide and Step-by-Step Tutorial > Step-by-step neural search tutorial using Qdrant > Step 2: Incorporate a Vector search engine
Now as we have a vector representation for all our records, we need to store them somewhere.
In addition to storing, we may also need to add or delete a vector, ... | [
0.024979503825306892,
-0.06834292411804199,
-0.03887026384472847,
0.013930290006101131,
0.03829303756356239,
-0.028142163529992104,
0.07862304151058197,
0.042784783989191055,
0.09608565270900726,
-0.023553846403956413,
0.017044447362422943,
0.039121098816394806,
0.06523729115724564,
-0.055... |
e6c33bf9-88a0-55dd-af94-10e2253bdb9a | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | Takeaways > Keep it miniCOIL-branded | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > Takeaways > Keep it miniCOIL-branded
We stayed loyal to certain features of the miniCOIL approach:
**Self-supervised.** No relevance labels. Training data is Wikipedia sentences, and the supervision is the geometry of a larger encoder, so adding a ... | [
0.029842402786016464,
-0.03488059341907501,
-0.030787650495767593,
-0.05624905973672867,
0.0421951562166214,
-0.06464178115129471,
0.05615326017141342,
0.027047041803598404,
0.04744549095630646,
-0.03413458168506622,
0.003962518181651831,
0.021700391545891762,
0.07371211796998978,
-0.01561... |
e6ce7de7-0d03-5e5f-8a31-2f671ec0e81e | /documentation/frameworks/dagster/ | Dagster | documentation | true | Dagster
[Dagster](https://dagster.io) is a Python framework for data orchestration built for data engineers, with integrated lineage, observability, a declarative programming model, and best-in-class testability.
The `dagster-qdrant` library lets you integrate Qdrant's vector database with Dagster, making it easy to ... | [
0.025197982788085938,
0.004216315224766731,
-0.05090898275375366,
-0.011151041835546494,
0.0536545068025589,
-0.036587245762348175,
0.08970056474208832,
0.03988053649663925,
0.025675471872091293,
0.004650963936001062,
-0.004279958549886942,
0.006654595490545034,
0.05456729233264923,
-0.028... | |
e6d06a1c-f757-54a9-81ea-c0f89c92deba | /documentation/fastembed/fastembed-rerankers/ | Reranking with FastEmbed | Goal of this Tutorial | documentation | false | Reranking with FastEmbed > Goal of this Tutorial
It's common to use [cross-encoder](https://sbert.net/examples/applications/cross-encoder/README.html) models as rerankers. This tutorial uses [Jina Reranker v2 Base Multilingual](https://jina.ai/news/jina-reranker-v2-for-agentic-rag-ultra-fast-multilingual-function-call... | [
0.030770914629101753,
-0.026939958333969116,
-0.048821430653333664,
-0.06829732656478882,
0.06742008030414581,
-0.0402035154402256,
0.07586153596639633,
0.049050044268369675,
0.042052000761032104,
0.01255890168249607,
0.053843505680561066,
-0.0006381383864209056,
0.06860339641571045,
-0.02... |
e6e668ff-cbf5-51fa-babb-d9cfbfc3182e | /articles/neural-search-tutorial/ | Neural Search 101: A Complete Guide and Step-by-Step Tutorial | What is neural search? | article | false | Neural Search 101: A Complete Guide and Step-by-Step Tutorial > What is neural search?
A regular full-text search, such as Google's, consists of searching for keywords inside a document.
For this reason, the algorithm can not take into account the real meaning of the query and documents.
Many documents that might be o... | [
0.012880168855190277,
-0.04745940491557121,
-0.0634119063615799,
-0.008601275272667408,
0.04409380629658699,
-0.002720351330935955,
0.07123520225286484,
0.06937193870544434,
0.09201464056968689,
-0.008112000301480293,
0.03277815878391266,
0.06060617417097092,
0.03130626678466797,
-0.023132... |
e6f5ae69-42db-560e-b872-00e637c83945 | /documentation/tutorials-build-essentials/rag-deepseek/ | 5-Minute RAG with DeepSeek | Setup Qdrant | documentation | true | 5-Minute RAG with DeepSeek > Setup Qdrant
```bash
python -m pip install "qdrant-client[fastembed]==1.19.1" requests
```
[Qdrant](https://qdrant.tech) will act as a knowledge base providing the context information for the prompts we'll be sending to the LLM.
You can get a free-forever Qdrant Cloud instance at https:/... | [
0.0371217280626297,
-0.041593775153160095,
-0.029212001711130142,
-0.05604993924498558,
0.06238529831171036,
-0.040688686072826385,
0.08560971170663834,
0.05067393183708191,
0.06902948766946793,
-0.07076457887887955,
0.026157362386584282,
0.018064845353364944,
0.05533229187130928,
-0.03464... |
e6f6e21e-a774-5f7f-9e85-62d9c6d61ff4 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Optimizing for Disk-Based Retrieval > Local NVMe/SSD Storage | documentation | false | Memory Tiers > Optimizing for Disk-Based Retrieval > Local NVMe/SSD Storage
On-disk retrieval benefits from fast, local storage. If you're self hosting Qdrant, use NVMe or SSD drives attached directly to the machine. Avoid network-attached storage. It is too slow for the sequential reads that vector search requires. | [
0.043850433081388474,
-0.06784576177597046,
-0.02985638752579689,
-0.042515963315963745,
0.044898297637701035,
-0.030511612072587013,
0.03857686370611191,
0.003740754909813404,
0.07757208496332169,
0.027556920424103737,
-0.009025348350405693,
-0.012990749441087246,
0.036718085408210754,
-0... |
e70900be-96bc-5f81-84bb-742371ba2421 | /documentation/data-synchronization/ | Data Synchronization | documentation | false | Data Synchronization
After migrating to Qdrant, maintaining consistency between Qdrant and your other data stores can be an ongoing operational concern. As records are created, updated, or deleted in your other sources, those changes often need to be reflected in Qdrant to keep search results accurate and fresh.
The ... | [
0.004639852326363325,
-0.03939171880483627,
-0.04806366190314293,
-0.024238942191004753,
0.04138163477182388,
-0.03676218166947365,
0.040097977966070175,
0.013529556803405285,
0.07927770912647247,
-0.014942898415029049,
0.019351866096258163,
0.022811394184827805,
0.05484208092093468,
-0.01... | |
e7112d41-73ff-55bf-955c-260146882a36 | /documentation/manage-data/points/ | Points | Upload Points > Idempotence | documentation | false | Points > Upload Points > Idempotence
All APIs in Qdrant, including point loading, are idempotent.
It means that executing the same method several times in a row is equivalent to a single execution.
In this case, it means that points with the same id will be overwritten when re-uploaded.
Idempotence property is usefu... | [
0.027990946546196938,
-0.029524607583880424,
-0.03202231973409653,
-0.0846528559923172,
0.025197399780154228,
-0.036159392446279526,
0.07528045028448105,
0.054653655737638474,
0.08682762831449509,
-0.028943981975317,
0.03393995761871338,
-0.0055511766113340855,
0.0095680458471179,
-0.00758... |
e72f7586-7672-5f74-bc83-510d31eb1764 | /documentation/manage-data/indexing/ | Indexing | Payload Index > Parameterized Index > Per-Element Index for Arrays of Objects > Differences from Regular Indexes | documentation | false | Indexing > Payload Index > Parameterized Index > Per-Element Index for Arrays of Objects > Differences from Regular Indexes
Outside nested filters, a per-element index answers most queries like a regular index of the field. Two kinds of conditions behave differently, because a per-element index evaluates them per elem... | [
0.0158653873950243,
-0.009034083224833012,
-0.06577350944280624,
-0.047705281525850296,
0.038059793412685394,
-0.027861187234520912,
0.04410811513662338,
0.01080583781003952,
0.07830739766359329,
-0.021534932777285576,
0.009595535695552826,
0.016128845512866974,
0.05877269431948662,
-0.015... |
e7607cf7-26f5-532f-b410-10933c3284df | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Collection Storage Size | documentation | true | Administration > Strict Mode > Maximum Collection Storage Size
It is possible to set the maximum size of a collection in terms of vectors and/or payload storage size.
Setting `max_collection_vector_size_bytes` and/or `max_collection_payload_size_bytes` caps the maximum byte size of a collection.
```python
from qdran... | [
0.012663583271205425,
-0.00321255368180573,
-0.029674915596842766,
-0.061805494129657745,
0.04149985685944557,
-0.055301960557699203,
0.032812029123306274,
0.04857104644179344,
0.0622241348028183,
-0.056167662143707275,
0.0023421726655215025,
0.001923564006574452,
0.06863557547330856,
-0.0... |
e77f980c-43e1-579f-b064-3255e021398d | /documentation/embeddings/ollama/ | Ollama | Embed Documents | documentation | true | Ollama > Embed Documents
`embed` takes a list of inputs and returns one vector per input, in the same order. This example uses the position of each input as the point ID:
```python
documents = [
"Qdrant is a vector search engine.",
"Ollama runs open models on your own hardware.",
]
response = ollama_client.e... | [
0.07061560451984406,
-0.06521836668252945,
-0.038002245128154755,
-0.06884128600358963,
0.07722492516040802,
-0.009127889759838581,
0.08469652384519577,
0.08170399814844131,
0.051017146557569504,
0.009241067804396152,
-0.020109251141548157,
0.02688816748559475,
0.004659401252865791,
-0.010... |
e78bed17-3e74-5b4b-9b8b-10bd2d93c091 | /documentation/capacity-planning/ | Capacity Planning | Calculating RAM and Disk Size > Dense Vectors > Quantized Vectors | documentation | true | Capacity Planning > Calculating RAM and Disk Size > Dense Vectors > Quantized Vectors
[Quantization](/documentation/manage-data/quantization/) creates a compressed copy of your vectors that speeds up search and shrinks memory use, at some cost to accuracy.
If you enable quantization, Qdrant stores this compressed cop... | [
0.03590669110417366,
-0.0708128809928894,
-0.05041729286313057,
-0.054601240903139114,
0.06532729417085648,
0.0011816939804702997,
0.0672282949090004,
0.02874884568154812,
0.12373344600200653,
-0.03255472332239151,
0.022925937548279762,
0.018623188138008118,
0.05563484877347946,
-0.0320144... |
e79747b2-a6bb-5c8c-8896-36c5e18275d3 | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | How HNSW Works | course | false | HNSW Indexing Fundamentals > How HNSW Works
### Graph Structure
HNSW works similarly by building a multi-layered graph where each vector is a node. The idea is that the graph has a hierarchical structure, where the top layer contains a smaller number of nodes that are broadly connected, and each lower layer has more ... | [
0.029770638793706894,
-0.055752914398908615,
-0.0577971413731575,
-0.0025590078439563513,
0.043646711856126785,
-0.029043003916740417,
0.0915829986333847,
0.06458303332328796,
0.03308267146348953,
-0.0036858271341770887,
0.03225107491016388,
0.05763309821486473,
0.046365365386009216,
0.003... |
e7a36e75-7fde-58d3-b5d8-6f3d17ec18a0 | /articles/rag-is-dead/ | Is RAG Dead? Why Long Context Windows Don't Replace RAG | Where Qdrant fits | article | false | Is RAG Dead? Why Long Context Windows Don't Replace RAG > Where Qdrant fits
If you choose retrieval, Qdrant provides the search layer. It offers dense and sparse vectors, [hybrid search](/documentation/search-tuning/hybrid-search/), filters for tenant isolation and permissions, and [quantization](/documentation/manage... | [
0.018378928303718567,
-0.023227890953421593,
-0.03317577764391899,
-0.03618467599153519,
0.06585510075092316,
-0.015397734940052032,
0.08443381637334824,
0.017682911828160286,
0.08955090492963791,
-0.05105986446142197,
-0.00100786704570055,
0.040856704115867615,
0.10092127323150635,
-0.016... |
e7aaa0c9-2902-5343-b015-d94b29304ebf | /documentation/frameworks/txtai/ | txtai | documentation | true | txtai
Qdrant might be also used as an embedding backend in [txtai](https://neuml.github.io/txtai/) semantic applications.
txtai simplifies building AI-powered semantic search applications using Transformers. It leverages the neural embeddings and their
properties to encode high-dimensional data in a lower-dimensional... | [
0.06327519565820694,
-0.03893684595823288,
-0.028097812086343765,
-0.030697857961058617,
0.043578531593084335,
-0.0321446992456913,
0.08254006505012512,
0.03736265376210213,
0.04189475253224373,
-0.02382339909672737,
0.07749412953853607,
0.01931110769510269,
0.08565416187047958,
-0.0137601... | |
e7ab159e-cd55-5289-99fd-652f1b50141d | /documentation/installation/ | Installation | Production > Qdrant Cloud | documentation | false | Installation > Production > Qdrant Cloud
You can set up production with the [Qdrant Cloud](https://qdrant.to/cloud), which provides fully managed Qdrant databases.
It provides horizontal and vertical scaling, one click installation and upgrades, monitoring, logging, as well as backup and disaster recovery. For more in... | [
-0.00475720502436161,
-0.018951619043946266,
-0.054232534021139145,
-0.047861672937870026,
0.03727492317557335,
-0.006714212708175182,
0.08884286880493164,
0.028463397175073624,
0.06784704327583313,
-0.020580636337399483,
0.02445257268846035,
-0.008992995135486126,
0.08403600752353668,
-0.... |
e7c283a4-54e1-5384-8981-c87c624da970 | /documentation/scaling/horizontal-scaling/ | Horizontal Scaling | How Many Qdrant Nodes Should I Run? > Which Configuration Is Right for You? | documentation | false | Horizontal Scaling > How Many Qdrant Nodes Should I Run? > Which Configuration Is Right for You?
In summary:
- One node is suitable for non-production workloads.
- Two nodes give you more capacity than one, without true high availability.
- Three or more nodes and a replication factor of two or higher are the gold st... | [
-0.005943095311522484,
-0.020794233307242393,
-0.07817026972770691,
-0.041800446808338165,
0.039877381175756454,
-0.02953040972352028,
0.08097926527261734,
0.07006345689296722,
0.1017877534031868,
-0.01881595142185688,
0.01567200757563114,
-0.013774172402918339,
0.04553673043847084,
-0.034... |
e7cc96dd-66fa-54c7-a939-ec4faa163d9c | /documentation/private-cloud/changelog/ | Changelog | 1.9.4 (2026-01-15) | documentation | false | Changelog > 1.9.4 (2026-01-15)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.22.1 |
| operator | 2.9.1 |
| qdrant-cluster-manager | v0.3.15 |
| qdrant-cluster-exporter | 1.7.6 |
Latest validated Qdrant version: 1.16.3
* Configurable lab... | [
0.060337331146001816,
-0.01973254233598709,
-0.07692570239305496,
-0.03292444720864296,
0.0628226101398468,
-0.06330174952745438,
0.05006466805934906,
0.04174426198005676,
0.035497963428497314,
-0.0404646135866642,
0.026236146688461304,
0.045925430953502655,
0.061276890337467194,
-0.054735... |
e7d77058-a864-5dbe-a057-3400d6b300f7 | /course/essentials/day-5/colbert-multivectors/ | Multivectors for Late Interaction Models | Querying with ColBERT | course | true | Multivectors for Late Interaction Models > Querying with ColBERT
To search using your ColBERT multivector field, embed your query and pass it directly to `query_points`:
```python
from fastembed import LateInteractionTextEmbedding
# Encode the query
colbert = LateInteractionTextEmbedding("colbert-ir/colbertv2.0")
co... | [
0.03995836526155472,
-0.03786583989858627,
-0.02465127222239971,
-0.022396864369511604,
0.05987279862165451,
-0.05552056431770325,
0.09188327938318253,
0.04300759732723236,
0.05072186887264252,
-0.018391042947769165,
0.04643717408180237,
0.02636561170220375,
0.04249528795480728,
-0.0215384... |
e7eef149-adf2-57f1-8a2c-26f308252948 | /documentation/search/search/ | Search | documentation | false | Search
Searching for the nearest vectors is at the core of many representational learning applications.
Modern neural networks are trained to transform objects into vectors so that objects close in the real world appear close in vector space.
It could be, for example, texts with similar meanings, visually similar pict... | [
0.03290046751499176,
-0.05355045944452286,
-0.055025696754455566,
-0.019344381988048553,
0.0714801624417305,
-0.0225001759827137,
0.037275657057762146,
0.01480042189359665,
0.06320061534643173,
0.004999267403036356,
0.010731778107583523,
0.049878112971782684,
0.09333502501249313,
-0.008954... | |
e7feb142-e846-565e-af25-fcb8f7335a3f | /documentation/embeddings/twelvelabs/ | TwelveLabs | Reduce Vector Size | documentation | true | TwelveLabs > Reduce Vector Size
Marengo 3.5 accepts an `embedding_dimension` parameter of `512`, `256`, or `128`. Shorter vectors make the index smaller and search faster, and longer vectors give better retrieval quality. Set the collection's `size` to the same value, and pass the same `embedding_dimension` when you e... | [
0.01856064237654209,
-0.0363173745572567,
-0.039600517600774765,
-0.05587686225771904,
0.05468026176095009,
-0.0634477287530899,
0.04746071249246597,
0.0705779418349266,
0.09764983505010605,
-0.02812206745147705,
0.029120106250047684,
0.04292897880077362,
0.040763042867183685,
-0.018300035... |
e817f578-ead4-5ec4-aa7c-62ae7f194b25 | /documentation/scaling/vertical-scaling/ | Vertical Scaling | How to Scale Vertically Self-Hosted | documentation | false | Vertical Scaling > How to Scale Vertically Self-Hosted
For self-hosted deployments, resize the underlying VM or container resources directly, then restart the affected nodes. If your collections have a replication factor of two or higher, you can resize nodes one at a time without downtime. | [
0.03805694356560707,
-0.04060719162225723,
-0.019342955201864243,
-0.044975657016038895,
0.08217892050743103,
-0.014671863056719303,
0.051844362169504166,
0.02030555158853531,
0.0655425637960434,
-0.04026130959391594,
0.03628802299499512,
-0.03825896233320236,
0.05035846307873726,
-0.02306... |
e82cbd0b-d50a-5877-9716-21e6e9ce3b3a | /course/essentials/day-3/hybrid-search-demo/ | Demo: Implementing a Hybrid Search System | What You'll Learn | course | false | Demo: Implementing a Hybrid Search System > What You'll Learn
Day 3
Build a complete hybrid search system with hands-on examples.
- Step-by-step hybrid search implementation
- RRF algorithm in practice
- Performance optimization techniques
- Testing and evaluation methods
**Follow along in Colab:** | [
0.016323426738381386,
-0.011259078048169613,
-0.06756048649549484,
-0.02657965011894703,
0.09637180715799332,
-0.03154833987355232,
0.02246255800127983,
0.04692083224654198,
0.06140199303627014,
-0.03617769107222557,
0.018599310889840126,
0.0010303739691153169,
0.09909168630838394,
-0.0433... |
e82ee3c7-56f4-5ef0-9f82-df64298903cd | /course/beginners/module-5/analyst-queries/ | Analyst Queries | The Analyst Investigation Query | course | true | Analyst Queries > The Analyst Investigation Query
For a focused investigation, run hybrid retrieval over dense and sparse text, scoped to one supplier and to elevated-risk signals from the last week. Put the filter inside each `Prefetch`, as in Modules 3 and 4, so each retriever returns 50 candidates that satisfy it.
... | [
0.03799603506922722,
-0.030424460768699646,
-0.04571959003806114,
-0.059107545763254166,
0.06638262420892715,
-0.02527497336268425,
0.024787986651062965,
0.044677600264549255,
0.0663897767663002,
-0.008646446280181408,
-0.0011724921641871333,
0.04495299234986305,
0.08530308306217194,
-0.01... |
e83b98d1-947b-5b76-8f2a-974e472109b2 | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | Step 11: Filtering With Payload Indexes | course | true | Demo: HNSW Performance Tuning > Step 11: Filtering With Payload Indexes
Run the same query with the index in place.
```python
print("Testing filtering WITH payload indexes...")
# Warmup
client.query_points(collection_name=collection_name, query=query_embedding, limit=1)
# Run multiple times for more reliable measur... | [
0.02595347911119461,
-0.03941168263554573,
-0.05065944045782089,
-0.024072011932730675,
0.046357519924640656,
-0.020955663174390793,
0.01635558158159256,
0.03514459356665611,
0.0822853222489357,
-0.011972326785326004,
0.03963911533355713,
0.04621557518839836,
0.05502265691757202,
-0.019074... |
e83bba30-7a84-57ed-a392-504b71d84eed | /documentation/manage-data/quantization/ | Quantization | Binary Quantization > 1.5-Bit and 2-Bit Quantization | documentation | false | Quantization > Binary Quantization > 1.5-Bit and 2-Bit Quantization
*Available as of v1.15.0*
**Binary quantization** storage can use **2 and 1.5 bits** per dimension, improving precision for smaller vectors. One-bit compression resulted in significant data loss and precision drops for vectors smaller than a thousand... | [
0.03247125446796417,
-0.04423722252249718,
-0.04706043750047684,
-0.04368593543767929,
0.04525589942932129,
-0.023699097335338593,
0.015339543111622334,
0.0443619005382061,
0.08686232566833496,
-0.03915935009717941,
0.03940536081790924,
-0.008404018357396126,
0.0670117512345314,
-0.0210813... |
e84c963e-f4c6-5da6-ba38-e255eff68470 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantClusterSnapshotSpec | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantClusterSnapshotSpec
_Appears in:_
- [QdrantClusterSnapshot](#qdrantclustersnapshot)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `cluster-id` _string_ | The cluster ID for which a Snapshot need to be takenThe cluster should be in the ... | [
0.013377721421420574,
-0.017971662804484367,
-0.010053114034235477,
-0.02182362973690033,
0.06551648676395416,
-0.05771150067448616,
0.046059802174568176,
0.061068713665008545,
0.08539477735757828,
-0.04142380133271217,
0.04604426771402359,
0.0006570499972440302,
0.05396676063537598,
-0.02... |
e858730a-e438-5c22-b248-f172508fc01e | /documentation/edge/edge-data-synchronization-patterns/ | Data Synchronization Patterns | documentation | false | Data Synchronization Patterns
This page describes patterns for synchronizing data between Qdrant Edge Shards and Qdrant server collections. For a practical end-to-end guide on implementing these patterns, refer to the [Qdrant Edge Synchronization Guide](/documentation/edge/edge-synchronization-guide/). | [
0.024426475167274475,
0.004623610991984606,
-0.06666108965873718,
-0.057043444365262985,
0.03004295565187931,
-0.06784093379974365,
0.10665249079465866,
0.03587986156344414,
0.11476406455039978,
0.005477527622133493,
0.016868075355887413,
0.015692558139562607,
0.06455590575933456,
-0.01923... | |
e876aee9-faad-5c9c-b3ee-4b054ec2f3f4 | /course/multi-vector-search/module-3/multi-stage-retrieval/ | Multi-Stage Retrieval with Universal Query API | The Critical Role of Oversampling | course | false | Multi-Stage Retrieval with Universal Query API > The Critical Role of Oversampling
Here's the most important concept in multi-stage retrieval: **you must retrieve more candidates in the prefetch stage than you want in your final results**.
This is called **oversampling**, and it's essential for maintaining search qua... | [
0.01442389003932476,
-0.06351488828659058,
-0.03185157850384712,
-0.02383943647146225,
0.046637967228889465,
-0.004655502736568451,
0.046393007040023804,
0.0069357180036604404,
0.10110621154308319,
-0.024902790784835815,
0.011733055114746094,
0.010073154233396053,
0.04914772883057594,
-0.0... |
e87a82de-6997-52e4-8328-e220cd455eec | /documentation/embeddings/mixedbread/ | Mixedbread | Reduce Vector Size | documentation | true | Mixedbread > Reduce Vector Size
The mxbai embedding models support Matryoshka truncation, so you can keep only the first dimensions of each vector. Pass `truncate_dim` when you load the model, and set the collection's `size` to the same value:
```python
small_model = SentenceTransformer("mixedbread-ai/mxbai-embed-lar... | [
0.08128144592046738,
-0.017708241939544678,
-0.01680600456893444,
-0.06514415144920349,
0.043726496398448944,
-0.02844328060746193,
0.04680739343166351,
0.025072257965803146,
0.05728577449917793,
-0.024858327582478523,
0.03429081290960312,
0.004501266870647669,
0.07483129948377609,
-0.0393... |
e87da1c9-fcab-5a20-be17-f8d697dddb19 | /articles/memory-consumption/ | Minimal RAM to Serve 1M Vectors | Conclusion | article | false | Minimal RAM to Serve 1M Vectors > Conclusion
In this article, we showed that Qdrant has flexibility in terms of RAM usage and can be used to serve large datasets. It provides configurable trade-offs between RAM usage and search speed. If you’re interested to learn more about Qdrant, [book a demo today](https://qdrant.... | [
0.0225902758538723,
-0.05076304450631142,
-0.045764900743961334,
-0.03038308583199978,
0.05412589758634567,
-0.05020468309521675,
0.1011156514286995,
0.026289910078048706,
0.08488894999027252,
-0.007522855419665575,
0.012271974235773087,
0.027122823521494865,
0.07975497841835022,
0.0025954... |
e88c8234-e585-52e9-bb91-3c67dc5c72a5 | /documentation/search-tuning/when-your-collection-outgrows-ram/ | When Your Collection Outgrows RAM | Rescoring Adds the Disk Read | documentation | false | When Your Collection Outgrows RAM > Rescoring Adds the Disk Read
`rescore` repairs part of the error that compression introduces. Qdrant reads the original vectors back after the dense prefetch and reorders the top candidates by their full-precision scores.
`oversampling` sets how many candidates Qdrant pre-selects f... | [
0.04873407259583473,
-0.06241302564740181,
-0.044575292617082596,
-0.04376118630170822,
0.0885007232427597,
-0.015615081414580345,
0.04209297150373459,
0.011799030005931854,
0.11954236775636673,
-0.022316277027130127,
0.020115692168474197,
0.019502485170960426,
0.046140119433403015,
0.0057... |
e895af17-6b8f-55be-ba55-b0d98681506b | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Vectors > How do I choose the right vector embeddings for my use case? | documentation | false | Qdrant Fundamentals > Vectors > How do I choose the right vector embeddings for my use case?
This depends on the nature of your data and the specific application. Consider factors like dimensionality, domain-specific models, and the performance characteristics of different embeddings. | [
0.024857468903064728,
-0.0385672003030777,
-0.022708283737301826,
-0.03999963402748108,
0.017355484887957573,
-0.04765557125210762,
0.08249831944704056,
0.05352592468261719,
0.07518280297517776,
-0.002436059294268489,
0.005343284923583269,
0.027473002672195435,
0.0440061129629612,
-0.03957... |
e8969d96-0076-5f56-abac-3fcc0bc96fa1 | /documentation/tutorials-operations/secure-and-expose-hybrid-cloud/ | Securing and Exposing a Hybrid Cloud Cluster | Enable API Key Authentication | documentation | true | Securing and Exposing a Hybrid Cloud Cluster > Enable API Key Authentication
Generate a key and store it as a Kubernetes secret:
```bash
API_KEY=$(openssl rand -hex 24)
kubectl create secret generic qdrant-api-key \
--from-literal=api-key=$API_KEY \
--namespace $KUBENS
```
You won't be able to apply the API key... | [
0.06798660755157471,
-0.006613621953874826,
-0.04913872852921486,
-0.049699604511260986,
0.031205633655190468,
-0.04730620235204697,
0.05914468318223953,
0.061168186366558075,
0.04636514559388161,
-0.03973766416311264,
0.013600212521851063,
0.0030940882861614227,
0.08729460835456848,
-0.03... |
e8994c9e-67a1-5df7-97c4-c81de576ace0 | /documentation/fastembed/fastembed-colbert/ | Working with ColBERT | ColBERT | documentation | false | Working with ColBERT > ColBERT
ColBERT is an embedding model that produces a matrix (multivector) representation of input text,
generating one vector per token (a token being a meaningful text unit for a machine learning model).
This approach allows ColBERT to capture more nuanced input semantics than many dense emb... | [
0.021475549787282944,
-0.03137640655040741,
-0.07442362606525421,
-0.04464852437376976,
0.07944256067276001,
-0.01944856345653534,
0.07934249192476273,
0.05624030902981758,
0.05607510730624199,
-0.0016554229659959674,
0.03538312762975693,
0.004944771062582731,
0.04023994132876396,
-0.04420... |
e8a5eeae-2005-593d-8486-3b070a7e39b1 | /articles/immutable-data-structures/ | Immutable Data Structures in Qdrant | How Does Immutability Help? > Perfect Hashing | article | false | Immutable Data Structures in Qdrant > How Does Immutability Help? > Perfect Hashing
| Volume | `ph::Function` | `std::hash::Hash` | `HashMap::get`|
|--------|----------------|-------------------|---------------|
| 1000 | 60ns | ~20ns | 34ns |
| 100k | 90ns | ~20ns ... | [
0.04346383735537529,
-0.02220575325191021,
-0.05629003047943115,
-0.053661368787288666,
0.08109086751937866,
-0.06554076075553894,
0.015170513652265072,
0.021454038098454475,
0.11172638088464737,
-0.008174825459718704,
0.0017566870665177703,
-0.005677633453160524,
0.03988461196422577,
-0.0... |
e8a9131e-9cce-594a-987f-391a04003e34 | /documentation/cloud-api/ | Qdrant Cloud API | documentation | false | Qdrant Cloud API
**Note:** This is not the Qdrant REST or gPRC API of the database itself. For database APIs & SDKs, see our list of [interfaces](/documentation/interfaces/) | [
-0.0004892267170362175,
-0.006426401436328888,
-0.0072389147244393826,
-0.04421501234173775,
0.06095712259411812,
-0.013170793652534485,
0.059599123895168304,
0.03803079202771187,
0.06924999505281448,
-0.04188743978738785,
0.05104439705610275,
0.02044551447033882,
0.06771858036518097,
-0.0... | |
e8b8790c-8145-5fc2-824b-99621b9ecd56 | /articles/triplet-loss/ | Advanced Introduction to Triplet Loss | Distance matrix | article | true | Advanced Introduction to Triplet Loss > Distance matrix
A distance matrix is a matrix of shape $(n, n)$ to hold distance values between all possible
pairs made from items in two $n$-sized collections.
This matrix can be used to vectorize calculations that would need inefficient loops otherwise.
Its calculation can be ... | [
0.03224547207355499,
-0.014273195527493954,
-0.051917921751737595,
-0.00008294729923363775,
0.05332402139902115,
0.016193116083741188,
0.03942197933793068,
0.05272432044148445,
0.08563239127397537,
-0.015132581815123558,
0.02708207629621029,
-0.027531299740076065,
0.04381929710507393,
-0.0... |
e8cf401d-0f16-56d7-a786-23a574be4a22 | /documentation/ops-monitoring/hybrid-cloud-datadog/ | Monitoring with Datadog | documentation | false | Monitoring with Datadog
| Time: 20 min | Level: Intermediate |
| --- | ----------- |
This tutorial will guide you through the process of setting up Datadog to monitor Qdrant clusters running in a Kubernetes cluster used for Hybrid or Private Cloud. | [
0.018366027623414993,
-0.006740012671798468,
-0.06725136935710907,
-0.00969009194523096,
0.03154345974326134,
-0.04992850124835968,
0.06232070177793503,
0.0321502685546875,
0.07428152114152908,
-0.026741579174995422,
0.011494372971355915,
0.021394427865743637,
0.050867948681116104,
-0.0413... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.