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 |
|---|---|---|---|---|---|---|---|
65ee4205-16d5-51db-b3a7-703c78e67ce4 | /course/beginners/module-5/clustering-risk-signals/ | Clustering Risk Signals | Retrieving Signals for a Supplier | course | true | Clustering Risk Signals > Retrieving Signals for a Supplier
`scroll` returns one page at a time, so page until it hands back a null offset. A single capped call would silently cluster a busy supplier on partial data.
```python
import numpy as np
from datetime import datetime, timedelta, timezone
def get_supplier_sig... | [
0.03871367499232292,
-0.012446096166968346,
-0.04738512635231018,
-0.03712446615099907,
0.06660814583301544,
-0.055422093719244,
0.06938918679952621,
0.06703653186559677,
0.07884611934423447,
-0.006301068235188723,
0.03185593709349632,
0.018671223893761635,
0.07011163234710693,
0.007110511... |
65f08b1b-6e3f-5f06-a78a-d516a304844d | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > TemplateMetadata | documentation | false | API Reference > qdrant.io/v1 > Resource Types > TemplateMetadata
_Appears in:_
- [PersistentVolumeClaimTemplate](#persistentvolumeclaimtemplate)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `name` _string_ | Name must be unique within a namespace. Is required when creating resources, alt... | [
0.021381689235568047,
-0.02636084333062172,
-0.07012275606393814,
-0.041228730231523514,
0.011817914433777332,
-0.056473925709724426,
0.054048970341682434,
0.06980320811271667,
0.054832298308610916,
-0.05571209266781807,
0.016911190003156662,
-0.016339726746082306,
0.06124025210738182,
-0.... |
66307367-13bc-5f43-b569-484f7105ed29 | /articles/product-quantization/ | Product Quantization for Vector Search | Using Qdrant for Product Quantization | article | false | Product Quantization for Vector Search > Using Qdrant for Product Quantization
If you’re already a Qdrant user, our documentation on [Product Quantization](/documentation/manage-data/quantization/#setting-up-product-quantization) will help you set and configure the new quantization for your data and achieve even
up t... | [
0.044976528733968735,
-0.06113540008664131,
-0.028611956164240837,
-0.05539717897772789,
0.04437023773789406,
-0.04228604584932327,
0.03446245566010475,
0.025925198569893837,
0.09865490347146988,
-0.02023172378540039,
0.008575724437832832,
0.03041238710284233,
0.06789407879114151,
-0.05208... |
6633846a-165b-5cb5-af5a-8897b2f22da9 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-5/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product | What's Actually Different | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product > What's Actually Different
The series taught the concepts. The toolkit removes the friction. Specifically:
- **No pipeline assembly.** You don't wire up Modal → training → Qdrant → mining → retraining. One command does it.
- **No ... | [
0.028453662991523743,
-0.0762103721499443,
-0.06593441963195801,
-0.015723546966910362,
0.050010837614536285,
-0.026825597509741783,
0.04136710986495018,
0.020901110023260117,
0.05882719159126282,
-0.022283410653471947,
0.015726152807474136,
0.045281101018190384,
0.055462080985307693,
-0.0... |
663533ba-2823-56f9-8a0e-153da51d8948 | /documentation/cloud-pricing-payments/ | Billing & Payments | Billing > Azure Marketplace | documentation | false | Billing & Payments > Billing > Azure Marketplace
Our [Azure Marketplace](https://portal.azure.com/#view/Microsoft_Azure_Marketplace/GalleryItemDetailsBladeNopdl/id/qdrantsolutionsgmbh1698769709989.qdrant-db/selectionMode~/false/resourceGroupId//resourceGroupLocation//dontDiscardJourney~/false/selectedMenuId/home/launc... | [
0.02801067754626274,
-0.003100502770394087,
-0.008803127333521843,
-0.023124992847442627,
0.054247260093688965,
-0.04588226601481438,
0.03501409664750099,
0.06982997804880142,
0.060207050293684006,
-0.040808163583278656,
0.060735054314136505,
0.016300808638334274,
0.05221216753125191,
-0.0... |
66398abe-ba0d-59c9-96cc-91ee8477a16e | /documentation/tutorials-basics/multimodal-search/ | Multimodal Search | Next Steps | documentation | false | Multimodal Search > Next Steps
Even image and text multimodal search alone supports many use cases: e-commerce, media management, content recommendation, emotion recognition, biomedical image retrieval, and spoken sign language transcription, among others.
Consider a shopper who has a picture of a product they want, ... | [
0.07867612689733505,
-0.07394590973854065,
-0.06457264721393585,
-0.014500895515084267,
0.05345604196190834,
-0.02635052055120468,
0.05122437700629234,
-0.023958787322044373,
0.0336485281586647,
-0.006841737311333418,
0.03043484501540661,
-0.006973491981625557,
0.08527837693691254,
-0.0216... |
663e6b93-ae81-5303-9655-7b78c8fda7ec | /documentation/production-checklist/ | Production Checklist | 5. Query Optimization | documentation | false | Production Checklist > 5. Query Optimization
- **Reduce tail latency with [delayed fan-outs](/documentation/search/low-latency-search/#use-delayed-fan-outs).**
For collections with a replication factor higher than one, use delayed fan-outs to automatically query a second replica if the first one doesn't respond within... | [
0.006392344832420349,
-0.04912740737199783,
-0.05837589129805565,
-0.054276417940855026,
0.07614173740148544,
-0.057450175285339355,
0.02713715098798275,
0.015405107289552689,
0.07783038169145584,
-0.04296400025486946,
0.05826441943645477,
0.007265688385814428,
0.05804517865180969,
-0.0067... |
667d1bd6-802c-5aa4-aa01-55faaec9d8d4 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Qdrant Adds > SIMD Acceleration | article | false | TurboQuant in Qdrant > What Qdrant Adds > SIMD Acceleration
The asymmetric scoring path (one float query against millions of quantized vectors) is the hot path of every search. The 4-bit and 2-bit kernels share most of a scoring core; 1-bit uses bit-plane scoring instead. | [
0.0584246963262558,
-0.03988710790872574,
-0.060336604714393616,
-0.0022217202931642532,
0.051773205399513245,
-0.006433380767703056,
0.04946728050708771,
0.01801188476383686,
0.08297187089920044,
-0.011256103403866291,
0.08558093011379242,
-0.006811823230236769,
0.06684831529855728,
-0.00... |
66bcdf3d-8bfa-5ce5-ad76-6c75a4aa7be0 | /documentation/snapshots/ | Snapshots | Storage > Azure Blob Storage | documentation | true | Snapshots > Storage > Azure Blob Storage
*Available as of v1.20.0*
To store snapshots in an Azure Blob Storage container, set `snapshots_storage` to `azure` and configure `azure_config` in the [configuration](/documentation/ops-configuration/configuration/) file:
```yaml
storage:
snapshots_config:
# Use 'azure... | [
-0.0014481996186077595,
0.005173630081117153,
0.00774634862318635,
-0.059363242238759995,
0.03551236912608147,
-0.06006592512130737,
0.04171690344810486,
0.036727868020534515,
0.04947293922305107,
-0.0167589969933033,
-0.012504812330007553,
0.007496269885450602,
0.07948705554008484,
0.0066... |
66d6b901-2710-52d0-b71c-bce064b28380 | /documentation/embeddings/twelvelabs/ | TwelveLabs | Embed Videos | documentation | true | TwelveLabs > Embed Videos
TwelveLabs embeds video asynchronously. Create an embedding task, poll it until its status is `ready`, and read the embeddings from its `data` field. With `embedding_scope` set to `clip`, Marengo splits the video into segments and returns embeddings for each one. By default, Marengo 3.5 retur... | [
0.049999501556158066,
-0.020500021055340767,
-0.05109251290559769,
-0.0382012240588665,
0.06689424067735672,
-0.03720803186297417,
0.04342682287096977,
0.053210727870464325,
0.0648111030459404,
-0.02004685439169407,
0.025815702974796295,
0.02288869582116604,
0.044382888823747635,
-0.026166... |
66d7cbe5-7f15-51cf-ac55-5a841adf9988 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > ComponentReference | documentation | false | API Reference > qdrant.io/v1 > Resource Types > ComponentReference
_Appears in:_
- [QdrantCloudRegionSpec](#qdrantcloudregionspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | APIVersion is the group and version of the component being referenced. | | |
| `kind` ... | [
0.022814292460680008,
-0.038874972611665726,
-0.035422757267951965,
-0.08351657539606094,
0.062064278870821,
-0.0477641224861145,
0.028986021876335144,
0.051980242133140564,
0.052652861922979355,
-0.0664290338754654,
0.04318390041589737,
0.022068534046411514,
0.05602345988154411,
-0.027747... |
66e32a15-656f-5fe7-94ea-f05fda4519a2 | /course/multi-vector-search/module-3/evaluating-pipelines/ | Evaluating Search Pipelines | Building Evaluation Pipelines | course | true | Evaluating Search Pipelines > Building Evaluation Pipelines
With all vectors stored in a single collection, we can build different pipelines **without re-indexing** - we simply query different named vectors.
### The Search Function
```python
def search_pipeline(
query_embedding: np.ndarray,
using: str,
p... | [
0.01714065670967102,
-0.0504569448530674,
-0.04018155857920647,
-0.041969768702983856,
0.04630274698138237,
-0.029984140768647194,
0.045079972594976425,
0.01988006755709648,
0.051957037299871445,
-0.025131145492196083,
-0.011672260239720345,
0.04744640365242958,
0.05003023147583008,
-0.033... |
66f2d485-d24c-5b8f-8376-1813bd4a6996 | /documentation/tutorials-build-essentials/data-ingestion-beginners/ | S3 Ingestion | Step 5: Embed and Upload | documentation | true | S3 Ingestion > Step 5: Embed and Upload
Loop over the products, build one [point](/documentation/manage-data/points/) for each, and upsert them all in one call:
```python
points: list[models.PointStruct] = []
for idx, product_id in enumerate(list_products(BUCKET)):
review, image = read_product(BUCKET, product_id)... | [
0.024304909631609917,
-0.03549715131521225,
-0.036836158484220505,
-0.03582286089658737,
0.07157816737890244,
-0.002393792849034071,
0.060477521270513535,
0.018300607800483704,
0.05903758481144905,
-0.00042913819197565317,
0.02232460305094719,
0.018642975017428398,
0.03941181302070618,
-0.... |
6714ea6c-d11f-540a-bc4c-f19db80ae4e4 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Scalar Quantization | article | false | Scalar Quantization for Vector Search > Scalar Quantization
Scalar quantization is a data compression technique that converts floating point values
into integers. In case of Qdrant `float32` gets converted into `int8`, so a single number
needs 75% less memory. It's not a simple rounding though! It's a process that m... | [
0.05117970332503319,
-0.016260726377367973,
-0.04445920139551163,
-0.06801614910364151,
0.01300094649195671,
0.008052735589444637,
0.051711082458496094,
0.0650743618607521,
0.11919181048870087,
-0.02049103006720543,
0.025669345632195473,
0.0023513217456638813,
0.033391982316970825,
-0.0226... |
67288468-0f38-5608-b6d9-305c1326742c | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Payloads (Metadata) > Payload Types | course | false | Points, Vectors and Payloads > Payloads (Metadata) > Payload Types
Qdrant supports a variety of payload data types, each optimized for different filtering conditions. Using the correct type is essential for performance and memory efficiency.
| Type | Description ... | [
0.02585841529071331,
-0.0255130585283041,
-0.048388417810201645,
-0.014821314252912998,
0.03875017911195755,
-0.04968111962080002,
0.03491704910993576,
0.039088938385248184,
0.10962304472923279,
-0.059575892984867096,
0.019009260460734367,
-0.0038815666921436787,
0.027894185855984688,
-0.0... |
673bcff1-3fba-5a17-8a85-5b609c292854 | /documentation/migrate-to-qdrant/from-milvus/ | From Milvus | Concept Mapping | documentation | false | From Milvus > Concept Mapping
| Milvus | Qdrant | Notes |
| :--- | :--- | :--- |
| Collection | Collection | One-to-one mapping |
| Partition | Payload field or separate collection | Use `--milvus.partitions` to specify which partitions to migrate |
| Schema fields | Payload | Non-vector fields become payload |
| `COS... | [
0.07936757057905197,
-0.054286301136016846,
-0.014392055571079254,
-0.053897757083177567,
0.07191246002912521,
-0.0037723842542618513,
0.053762029856443405,
0.05917081981897354,
0.05378378927707672,
-0.04556513950228691,
0.02444850653409958,
0.0014735201839357615,
0.027313239872455597,
-0.... |
6748cdf7-2563-5efd-a468-6280de19889b | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Embedding Comparison | course | false | Points, Vectors and Payloads > Embedding Comparison
| Feature | FastEmbed | Cloud Providers (incl. Qdrant Inference) | Open Source Models |
|---------------|-----------------------------------------|------------------------------------------|--------------------... | [
0.02878757193684578,
-0.035952091217041016,
-0.03420083597302437,
-0.04442695155739784,
0.06643560528755188,
-0.030105387791991234,
0.08741854131221771,
0.011579804122447968,
0.07233631610870361,
-0.048255257308483124,
0.012701858766376972,
-0.007279444485902786,
0.021368546411395073,
-0.0... |
675f3c5e-f763-52d9-b4fc-bde0df64083b | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 4. Ensuring Disaster Recovery With Database Backups and Snapshots > Full Backups or Snapshot Restores? | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 4. Ensuring Disaster Recovery With Database Backups and Snapshots > Full Backups or Snapshot Restores?
For disaster recovery scenarios, you should use full backups instead of snapshots. Snapshots are primarily designed for moving data between clusters, whereas ... | [
0.012391794472932816,
-0.023350786417722702,
-0.05630704388022423,
-0.027312327176332474,
0.05390241742134094,
-0.008639723062515259,
0.050134047865867615,
-0.0027164407074451447,
0.08544407784938812,
-0.022672971710562706,
0.03479618951678276,
0.04245152324438095,
0.02405453473329544,
-0.... |
6762c310-392f-5b83-870f-87961ab12990 | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | When Not to Use HNSW | course | false | HNSW Indexing Fundamentals > When Not to Use HNSW
### Small Collections
For collections with fewer than 10,000 vectors, brute force is often faster and uses less RAM than building HNSW.
### Exact Search Requirements
HNSW is approximate. If you need exact results, use brute force.
### Extreme Memory Constraints
Fo... | [
0.034092750400304794,
-0.046093493700027466,
-0.04598480835556984,
-0.06022528558969498,
0.05695626512169838,
-0.03949078172445297,
0.034171439707279205,
0.030377008020877838,
0.10388439893722534,
-0.03458937630057335,
0.019141051918268204,
0.028821153566241264,
0.04301106929779053,
-0.006... |
677d74e1-b90f-5a06-bdfa-d84c9c8b3abb | /documentation/agentic-tools/skills/ | Agent Skills | documentation | false | Agent Skills
Qdrant ships a set of agent skills: structured knowledge files that help your AI coding assistant think like a solutions architect, not just retrieve documentation.
> Skills are hosted at [skills.qdrant.tech](https://skills.qdrant.tech).
The recommended way to get started is the [Qdrant Advisor](#the-qd... | [
0.009636955335736275,
-0.06470809876918793,
-0.0780840814113617,
-0.03656996041536331,
0.05466026812791824,
-0.059694696217775345,
0.033996712416410446,
0.024918315932154655,
0.07540908455848694,
-0.04160936176776886,
0.06494423747062683,
-0.011469049379229546,
0.06298425793647766,
-0.0322... | |
67801c78-877e-5bda-be38-fb2b5dc666c4 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantClusterSpec | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantClusterSpec
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `resources` _[Resources](#resources)_ | Resources specifies the resources to allocate for each Qdrant node. | | |
| `security` _[QdrantSecurityContext](#qdrantsecuritycontext)_... | [
0.04244617000222206,
-0.055836014449596405,
-0.04912464693188667,
-0.03490419313311577,
0.06601632386445999,
-0.04826592281460762,
0.06554801017045975,
0.06923634558916092,
0.038596831262111664,
-0.02904505282640457,
0.046817224472761154,
-0.009293450973927975,
0.05426100268959999,
-0.0289... |
67816e56-3959-5441-911f-cf407a995864 | /course/beginners/module-1/distance-metrics/ | Comparing Meaning: Distance Metrics | course | false | Comparing Meaning: Distance Metrics
Module 1
Once we have vectors, we need a way to measure how similar two of them are. Different metrics suit different situations. | [
0.014386186376214027,
-0.02585820108652115,
-0.041914988309144974,
-0.03011864796280861,
0.05158543214201927,
-0.01255398616194725,
0.05266933888196945,
0.04079244285821915,
0.09598672389984131,
0.001776441466063261,
0.03310409560799599,
0.026695014908909798,
0.04065690562129021,
0.0120253... | |
678bc4b2-2e07-57f9-b14f-56770478429d | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | Performance considerations | documentation | true | How to Implement Multitenancy and Custom Sharding in Qdrant > Performance considerations
The speed of indexation may become a bottleneck if you are adding large amounts of data in this way, as each user's vector will be indexed into the same collection. To avoid this bottleneck, consider _bypassing the construction of... | [
0.02492675371468067,
-0.027602164074778557,
-0.051269616931676865,
0.006162519101053476,
0.05249747633934021,
-0.039274655282497406,
0.07874037325382233,
0.0345136858522892,
0.0689384862780571,
-0.01959291473031044,
0.02442125231027603,
0.0337064154446125,
0.052605267614126205,
-0.02310848... |
67b0e3fe-eaf4-5047-863d-9f3efbd76b80 | /documentation/embeddings/jina-embeddings/ | Jina AI | Next Steps | documentation | false | Jina AI > Next Steps
- [Filter search results](/documentation/search/filtering/) by payload fields, for example to search only images.
- [Jina AI Embedding API documentation](https://jina.ai/embeddings/), which lists every model, input type, and parameter.
- [Combine Jina AI vectors with sparse vectors](/documentation... | [
0.03287920728325844,
-0.0608503483235836,
-0.02475285902619362,
-0.04784272611141205,
0.08504374325275421,
0.004970587324351072,
0.05010136589407921,
0.0044630346819758415,
0.04983469843864441,
-0.043394461274147034,
0.06550315767526627,
0.031661003828048706,
0.07535132020711899,
-0.019162... |
67b66d7b-d594-5ac5-b2a9-2212df5a8f63 | /course/beginners/module-2/top-k-retrieval/ | Top-K Retrieval | course | true | Top-K Retrieval
Module 2
A search query is converted into a vector using the same embedding model used to embed your documents. Qdrant finds the K points in the collection whose vectors are most similar to the query vector, ranked by similarity score.
```python
results = client.query_points(
collection_name="art... | [
0.050406262278556824,
-0.08510130643844604,
-0.0196805652230978,
-0.04416337236762047,
0.059897590428590775,
-0.029099181294441223,
0.07592199742794037,
0.03875536844134331,
0.10170082747936249,
-0.01476619765162468,
0.03188266605138779,
0.008556271903216839,
0.06112249940633774,
-0.034212... | |
67cb4e25-5597-5586-8fb9-dc0a67256782 | /course/beginners/module-1/embeddings/ | How It Works: Embeddings | course | true | How It Works: Embeddings
Module 1
### What Is an Embedding?
An embedding is a [vector](): a list of numbers that captures meaning. Semantic search works by converting text into embeddings, text with similar meaning produces embeddings that sit close together in high-dimensional space, and text with different meaning... | [
0.018083885312080383,
-0.024043839424848557,
-0.05721504986286163,
-0.038496233522892,
0.03487562760710716,
-0.0055474708788096905,
0.08266104012727737,
0.06850983202457428,
0.08980389684438705,
-0.009901659563183784,
0.0022559636272490025,
0.022511612623929977,
0.03002588450908661,
-0.026... | |
67d89893-c47d-524c-ba57-1720dbd7c6db | /documentation/ops-optimization/read-write-contention/ | Read-Write Contention | Step 6: Try Async I/O | documentation | true | Read-Write Contention > Step 6: Try Async I/O
*Linux only. Requires kernel support.*
If your vectors or payload are on disk, [async I/O](/articles/io_uring/) can reduce the time Qdrant spends waiting on disk reads. By default, Qdrant reads data synchronously: it sends a request, waits for the response, then sends the... | [
0.028265293687582016,
-0.03982722759246826,
-0.040651723742485046,
-0.008308058604598045,
0.06614553183317184,
-0.025570206344127655,
0.02370326966047287,
-0.00005251883703749627,
0.07719027251005173,
-0.006904753856360912,
-0.00873285997658968,
0.0019291145727038383,
0.0575563870370388,
0... |
67f75a21-667f-5040-9be8-9c66888905c6 | /course/essentials/day-5/universal-query-api/ | The Universal Query API | course | false | The Universal Query API
Day 5
Picture this: a customer types "leather jackets" into your store's search bar. You want to show items that match the style semantically - so a bomber jacket surfaces even if it doesn't mention "leather jackets" verbatim - but you also need to enforce your business rules. Only products un... | [
0.029619432985782623,
-0.05572701245546341,
-0.060541171580553055,
-0.03246056288480759,
0.04543225094676018,
-0.03484329208731651,
0.03133554011583328,
0.028045300394296646,
0.06289659440517426,
0.014885885640978813,
0.07499398291110992,
0.0693453848361969,
0.08804795145988464,
-0.0369694... | |
67f7c585-6130-5a60-94ec-deedfdd9a6de | /documentation/ops-monitoring/hybrid-cloud-prometheus/ | Monitoring with Grafana and Prometheus | Prerequisites | documentation | false | Monitoring with Grafana and Prometheus > Prerequisites
This tutorial assumes that you already have a Kubernetes cluster running and a Qdrant database deployed in it, using either a Hybrid Cloud or Private Cloud deployment. You should also have `kubectl` and `helm` configured to interact with your cluster. | [
0.0028170256409794092,
-0.02497333288192749,
-0.05239816755056381,
-0.03794506937265396,
0.08211125433444977,
-0.037391092628240585,
0.08558851480484009,
0.03934864327311516,
0.04296136274933815,
-0.005840110592544079,
0.04093536362051964,
0.0076696365140378475,
0.07211467623710632,
-0.023... |
682012e6-8781-55d5-ac21-91f642037089 | /articles/what-is-a-vector-database/ | What is a Vector Database? | The Vector Search Workflow | article | false | What is a Vector Database? > The Vector Search Workflow
Before diving into the individual concepts, it helps to see the full picture. Regardless of the use case, the underlying vector search workflow consists of two complementary paths: the **ingestion path**, where data is processed and stored as vectors, and the **q... | [
0.014330631121993065,
-0.054653167724609375,
-0.06588442623615265,
-0.03381752595305443,
0.058227233588695526,
-0.010515222325921059,
0.05570255219936371,
0.021537119522690773,
0.07296796143054962,
-0.03128395229578018,
0.041148584336042404,
0.021521180868148804,
0.04707346111536026,
-0.00... |
684cef48-f413-5d0d-8712-eacf53026dc5 | /documentation/tutorials-search-engineering/collaborative-filtering/ | Collaborative Filtering | Implementation > Convert to sparse | documentation | true | Collaborative Filtering > Implementation > Convert to sparse
If you want to search across numerous reviews from different users, you can represent these reviews in a sparse matrix.
```python
# Convert ratings to sparse vectors
user_sparse_vectors = defaultdict(lambda: {"values": [], "indices": []})
for row in ratings... | [
0.046168096363544464,
-0.03199053555727005,
-0.04865700751543045,
-0.055924542248249054,
0.0896330401301384,
-0.012966765090823174,
0.08423609286546707,
0.0313260480761528,
0.04090727120637894,
-0.0017000720836222172,
0.024921227246522903,
0.020204203203320503,
0.10624982416629791,
-0.0120... |
685a3203-f8d4-5305-9043-cf3800d4bf29 | /documentation/ops-configuration/running-with-gpu/ | Running with GPU | Known limitations | documentation | true | Running with GPU > Known limitations
* **Platform Support:** Docker images are only available for Linux x86_64. Windows, macOS, ARM, and other platforms are not supported.
* **Memory Limits:** Each GPU can process up to 16GB of vector data per indexing iteration.
Due to this limitation, you should not create segment... | [
-0.01640530861914158,
-0.06095875799655914,
-0.050497472286224365,
-0.026557007804512978,
0.06562512367963791,
-0.031998343765735626,
0.0290514025837183,
0.011165673844516277,
0.10023169219493866,
-0.032006025314331055,
0.026130210608243942,
-0.00474907411262393,
0.054526373744010925,
-0.0... |
6867ea21-e15b-50c3-a5b2-d20291bcbe35 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | The Good, the Bad and the Ugly > Dense Retrieval | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > The Good, the Bad and the Ugly > Dense Retrieval
How to capture the meaning? Bag-of-words models like BM25 assume that words are placed in a text independently, while linguists say:
> "You shall know a word by the company it keeps" - John Rupert Firth
This id... | [
0.048132915049791336,
-0.03349507972598076,
-0.06220412626862526,
-0.06326252967119217,
0.05130835250020027,
-0.033844947814941406,
0.05155659839510918,
0.011738677509129047,
0.06539928913116455,
-0.017724594101309776,
0.05298582464456558,
0.03842687979340553,
0.07847927510738373,
-0.00770... |
68696b0c-59f1-50b5-87fd-5d22fd7e2097 | /documentation/embeddings/qdrant-cloud-inference/ | Qdrant Cloud Inference | Embed Images | documentation | true | Qdrant Cloud Inference > Embed Images
Pass an `Image` with an image URL or base64 data and the vision model. This example stores an image and searches it with text:
```python
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, Image, Document
client = QdrantClient(
url="https://x... | [
0.050185345113277435,
-0.04746898263692856,
-0.04191409423947334,
-0.06884970515966415,
0.08677800744771957,
-0.012956898659467697,
0.06381440162658691,
0.011234648525714874,
0.04154200851917267,
-0.011051381938159466,
0.017170527949929237,
-0.00495888851583004,
0.06279771029949188,
-0.027... |
686f8a12-46ca-506c-9a2d-3e3fd0ec9896 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | Detailed Benchmarks | article | false | TurboQuant in Qdrant > Detailed Benchmarks
* **TQ 4-bit is competitive with SQ at half the storage.** On 7 of 10 datasets TQ 4-bit trails SQ by 2.3 pp or less (`arxiv-384` is the widest gap). On the other three it *beats* SQ: `dbp-oai` (+4.6 pp), `cohere` (+2.6 pp), and `laion` (+1.6 pp). The pattern is consistent: wh... | [
0.0510895699262619,
-0.00782931037247181,
-0.04743001237511635,
-0.014551112428307533,
0.05218876153230667,
-0.013842438347637653,
0.03980004042387009,
0.019159652292728424,
0.05367415025830269,
-0.019559616222977638,
0.03723886236548424,
0.009225490503013134,
0.055153604596853256,
-0.0325... |
6879a84b-fcd8-5cc2-8fc7-d6497556580d | /documentation/edge/edge-quickstart/ | Quickstart | Modify the Vector Schema | documentation | true | Quickstart > Modify the Vector Schema
You can add or remove named vectors to an existing Edge Shard's schema. This is useful when migrating to a new embedding model or adding hybrid search to an Edge Shard that already contains data.
For example, to add a sparse vector for [BM25 keyword search](/documentation/edge/ed... | [
0.06387041509151459,
-0.03988172858953476,
-0.03694567829370499,
-0.02829492650926113,
0.06136070936918259,
-0.030059201642870903,
0.04960773140192032,
0.033620454370975494,
0.03807589411735535,
-0.026366254314780235,
0.06858684122562408,
0.03501433879137039,
0.031885597854852676,
-0.01878... |
6883c957-a109-5b7b-8444-4280c42d4f3c | /documentation/tutorials-build-essentials/agentic-rag-crewai-zoom/ | Agentic RAG with CrewAI | Usage > The Data Pipeline | documentation | true | Agentic RAG with CrewAI > Usage > The Data Pipeline
At the heart of our system is the data processing pipeline:
```python
class MeetingData:
def _initialize(self):
self.data_dir = Path(__file__).parent.parent / 'data'
self.meetings = self._load_meetings()
self.qdrant_client = Qdra... | [
0.029533930122852325,
-0.02575809136033058,
-0.03140640631318092,
-0.021555660292506218,
0.03505465015769005,
-0.02741486020386219,
0.05405158922076225,
0.02013896033167839,
0.055193159729242325,
-0.04041096195578575,
-0.029344607144594193,
0.04684098809957504,
0.044966235756874084,
-0.039... |
6889cf7a-58d2-520d-af78-4e226afdc756 | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | documentation | false | How to Implement Multitenancy and Custom Sharding in Qdrant
We are seeing the topics of [multitenancy](/documentation/manage-data/multitenancy/) and [distributed deployment](/documentation/scaling/distributed_deployment/#sharding) pop-up daily on our [Discord support channel](https://qdrant.to/discord). This tells us ... | [
0.012392990291118622,
-0.03331379219889641,
-0.0535396970808506,
-0.01477894652634859,
0.045252058655023575,
-0.07478545606136322,
0.08505722135305405,
0.05614004284143448,
0.061590876430273056,
-0.022357244044542313,
0.0378977432847023,
0.008769938722252846,
0.08595626056194305,
-0.007353... | |
6892bae4-4915-5c17-afd6-bbbd24605408 | /course/essentials/day-3/hybrid-search/ | Hybrid Search and the Universal Query API | Reciprocal Rank Fusion (RRF) | course | false | Hybrid Search and the Universal Query API > Reciprocal Rank Fusion (RRF)
The original scores returned by each method are primarily used to rank the documents by their relevance, so they define the order of how good each result is. RRF does not take the scores into account, but just the ranking defined by them, and cal... | [
0.011175359599292278,
-0.037917498499155045,
-0.04596240818500519,
-0.07950355112552643,
0.06353868544101715,
-0.012133799493312836,
0.0650874525308609,
0.05667055770754814,
0.0970168337225914,
-0.04015861824154854,
0.03460199013352394,
-0.0017630313523113728,
0.043740659952163696,
0.00865... |
6893205e-2ff0-5992-a318-ed7f142e2410 | /documentation/search/search/ | Search | Search API | documentation | true | Search > Search API
Note that payload and vector data is missing in these results by default.
See [payload and vector in the result](#payload-and-vector-in-the-result) on how
to include it.
If the collection was created with multiple vectors, the name of the vector to use for searching should be provided:
```python
... | [
0.032363589853048325,
-0.04226658120751381,
-0.03307561203837395,
-0.03186953440308571,
0.062043704092502594,
-0.03792351856827736,
0.052927494049072266,
0.0476895235478878,
0.06698780506849289,
-0.047635070979595184,
0.03083321824669838,
0.05133409425616264,
0.017016684636473656,
-0.00933... |
6895e063-f259-51d2-a4fc-656c40946ef1 | /documentation/search-tuning/candidate-depth/ | Candidate Depth: How Much Retrieval Is Enough? | documentation | false | Candidate Depth: How Much Retrieval Is Enough?
Before you tune candidate depth, use the [pre-tuning checks](/documentation/search-tuning/before-tuning-a-qdrant-collection/) to verify index state and set a labeled baseline. Everything below measures against that baseline.
Candidate depth is the number of candidates a ... | [
0.0064659276977181435,
-0.06236451491713524,
-0.01700618304312229,
-0.049160465598106384,
0.03020343743264675,
-0.0500912182033062,
0.042103108018636703,
0.075025275349617,
0.10876908153295517,
-0.02196539379656315,
0.028749097138643265,
0.009379295632243156,
0.037883613258600235,
-0.05289... | |
68b5ce3d-968a-525e-ba63-6a507044dd1f | /documentation/ops-optimization/read-write-contention/ | Read-Write Contention | Step 9: Scale Vertically | documentation | false | Read-Write Contention > Step 9: Scale Vertically
Like Step 8, this step adds capacity rather than reallocating it. Where horizontal scaling distributes load across more nodes, vertical scaling gives each node more resources to work with.
**CPU.** More vCPUs mean the optimizer and queries share a larger pool. The rati... | [
0.006000038702040911,
-0.05571102723479271,
-0.06829056143760681,
-0.002352821407839656,
0.0674838051199913,
-0.0015844989102333784,
0.040663015097379684,
0.02944406308233738,
0.08491566777229309,
-0.01552229281514883,
-0.002167847938835621,
0.0015404262812808156,
0.03249279037117958,
-0.0... |
68c08f73-d035-5063-9acd-bd92ecc41c53 | /documentation/migrate-to-qdrant/from-redis/ | From Redis | Gotchas | documentation | false | From Redis > 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](/documentatio... | [
0.02739889733493328,
-0.047119393944740295,
-0.03667827695608139,
-0.05590181425213814,
0.04251636192202568,
-0.03652888163924217,
0.031104879453778267,
0.036396585404872894,
0.05029692128300667,
-0.03511761501431465,
0.031089037656784058,
0.04383907467126846,
0.048498738557100296,
-0.0693... |
68d3dc3f-4344-54dd-b2c0-b0b4fb1122ee | /articles/bm42/ | BM42: Attention-Based Sparse Embeddings for Hybrid Search | The best of both worlds > Attention is all you need | article | false | BM42: Attention-Based Sparse Embeddings for Hybrid Search > The best of both worlds > Attention is all you need
In our implementation, we use the `sentence-transformers/all-MiniLM-L6-v2` model, which gives a huge boost in the inference speed compared to the SPLADE models. In practice, any transformer model can be used... | [
0.04334047809243202,
-0.023380229249596596,
-0.042221371084451675,
-0.041995514184236526,
0.030196290463209152,
-0.026525011286139488,
0.07393235713243484,
0.01799626089632511,
0.018020933493971825,
0.008541560731828213,
0.018764402717351913,
0.020109985023736954,
0.05667576938867569,
-0.0... |
6915b21e-c676-5e38-94b1-2f395a056879 | /course/beginners/module-2/from-idea-to-system/ | From Idea to System | course | false | From Idea to System
Module 2
In Module 1, we saw how search evolved from matching words to understanding meaning. Now we move from theory to actual system design. This module covers every building block you need to go from raw text to a running Qdrant collection.
- **Raw Text**
Documents, articles, PDFs
- **Chunk**... | [
0.03877854347229004,
-0.06888148188591003,
-0.0593612976372242,
-0.024959484115242958,
0.08330319821834564,
-0.05012594163417816,
0.034264255315065384,
0.037162523716688156,
0.07445728033781052,
-0.03090701811015606,
0.030289147049188614,
0.0212223082780838,
0.05991566926240921,
-0.0154670... | |
692e3e40-2511-58d6-bbca-9c602d7cabc4 | /documentation/fastembed/fastembed-splade/ | Working with SPLADE | documentation | false | Working with SPLADE
SPLADE is a novel method for learning sparse text representation vectors, outperforming BM25 in tasks like information retrieval and document classification. Its main advantage is generating efficient and interpretable sparse vectors, making it effective for large-scale text data. | [
0.0511818565428257,
-0.044459737837314606,
-0.05102897807955742,
-0.0755716860294342,
0.05022049695253372,
-0.0395951047539711,
0.06119203940033913,
0.03660615533590317,
0.020678685978055,
-0.0022892444394528866,
0.016551552340388298,
0.018907608464360237,
0.04698215052485466,
0.0215485412... | |
6947848d-9b09-5556-b5cf-58e42d791b12 | /documentation/ops-monitoring/hybrid-cloud-datadog/ | Monitoring with Datadog | Step 4: Understand the Cost of Collecting Every Metric | documentation | true | Monitoring with Datadog > Step 4: Understand the Cost of Collecting Every Metric
The `metrics: - .*` setting in Step 2 collects every metric the Qdrant exporter and operator expose, with no filtering. On most Datadog plans, metrics ingested through a custom OpenMetrics check are billed as [custom metrics](https://docs... | [
0.030553605407476425,
-0.02163279429078102,
-0.037006575614213943,
0.01605614647269249,
0.061248596757650375,
-0.03510215878486633,
0.07789196074008942,
0.061712928116321564,
0.0669553279876709,
-0.041842587292194366,
0.04220718517899513,
0.012424069456756115,
0.0406767837703228,
-0.033063... |
6948fb94-2f22-5c4d-8965-4a06a312fafc | /documentation/cloud/cluster-scaling/ | Scale Clusters | Horizontal Scaling | documentation | false | Scale Clusters > Horizontal Scaling
Vertical scaling can be an effective way to improve the performance of a cluster and extend the capacity, but it has some limitations. The main disadvantage of vertical scaling is that there are limits to how much a cluster can be expanded. At some point, adding more resources to a ... | [
0.02319270186126232,
-0.005381675437092781,
-0.04592590779066086,
-0.04127979651093483,
0.08305966109037399,
-0.04242146387696266,
0.06570803374052048,
0.06963389366865158,
0.08235355466604233,
-0.04860260710120201,
0.023321209475398064,
0.020220845937728882,
0.01403659675270319,
-0.032255... |
69496b9a-70cc-5a7b-bc26-a35d3fa2ad0c | /articles/turboquant-quantization/ | TurboQuant in Qdrant | When to Use TurboQuant | article | false | TurboQuant in Qdrant > When to Use TurboQuant
A practical guide:
* **You currently run SQ** → try TQ 4-bit. Comparable recall (often within 1–2 pp; sometimes higher) at half the memory. The easiest upgrade call on the ladder.
* **You currently run BQ at any bit depth** → try TurboQuant at the same storage budget (BQ ... | [
0.007828955538570881,
-0.04113749414682388,
-0.027482355013489723,
-0.03558289632201195,
0.02255963906645775,
-0.0030187887605279684,
0.016188448294997215,
0.028541630133986473,
0.0846254825592041,
-0.03748466074466705,
0.022171970456838608,
0.01480631623417139,
0.009279614314436913,
-0.02... |
69508d9d-4022-58e2-8249-a847aa2c8986 | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | How We Tested the Final Product > Crash Testing: Can Gridstore Handle the Pressure? | article | false | Introducing Gridstore: Qdrant's Custom Key-Value Store > How We Tested the Final Product > Crash Testing: Can Gridstore Handle the Pressure?
Designing for crash resilience is one thing, and proving it works under stress is another. To push Qdrant’s data integrity to the limit, we built [**Crasher**](https://github.com... | [
0.03709947690367699,
0.0026327071245759726,
-0.04077238589525223,
-0.029118098318576813,
0.06945683807134628,
-0.04951974377036095,
0.03946007415652275,
-0.002341418294236064,
0.053121864795684814,
-0.02843143790960312,
0.028505094349384308,
0.021056363359093666,
0.0634198784828186,
-0.026... |
69525c00-f014-5468-afc0-651ed1a453f5 | /course/essentials/day-4/large-scale-ingestion/ | Large-Scale Data Ingestion | The Collection Configuration | course | true | Large-Scale Data Ingestion > The Collection Configuration
When a collection is too large to hold in memory, each structure takes a `memory` parameter that says where it lives. `pinned` stays on the heap, `cached` is memory-mapped and pre-warmed, and `cold` is memory-mapped and read on demand.
```python
from qdrant_cl... | [
0.039018068462610245,
-0.024525167420506477,
-0.040850795805454254,
-0.02774057537317276,
0.028829392045736313,
-0.05054774135351181,
0.0506109893321991,
0.06918409466743469,
0.08015182614326477,
-0.014027085155248642,
0.023382367566227913,
0.02182779461145401,
0.025394944474101067,
-0.005... |
696c9922-72ca-598b-a2b1-90958b98d5d4 | /articles/search-feedback-loop/ | Relevance Feedback in Information Retrieval | Query Refinement | article | false | Relevance Feedback in Information Retrieval > Query Refinement
There are several ways to refine a query based on relevance feedback.
Globally, we prefer to distinguish between two approaches: modifying the query as text and modifying the vector representation of the query. | [
0.031287889927625656,
-0.03408895805478096,
-0.04787803068757057,
-0.08007282018661499,
0.031499799340963364,
-0.01430375687777996,
0.053955718874931335,
0.04953882098197937,
0.043256957083940506,
0.025032732635736465,
0.04213038831949234,
0.03199244290590286,
0.07369734346866608,
-0.01476... |
696da0b3-da0b-5da3-9bff-2284b1b86234 | /documentation/tutorials-basics/search-beginners-local/ | Semantic Search 101 | 4. Create a Collection | documentation | true | Semantic Search 101 > 4. Create a Collection
All data in Qdrant is organized by collections. In this case, you are storing books, so we are calling it `my_books`.
```python
client.create_collection(
collection_name="my_books",
vectors_config=models.VectorParams(
size=encoder.get_sentence_embedding_dim... | [
0.04407454654574394,
-0.04506062716245651,
-0.022825203835964203,
-0.03910977765917778,
0.04949154704809189,
-0.023317035287618637,
0.07781427353620529,
0.09514433145523071,
0.09262000024318695,
-0.019897161051630974,
0.03377017006278038,
0.023720867931842804,
0.06564797461032867,
-0.01215... |
696f3cac-93fd-5303-b2a9-e95fa6139651 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | The Good, the Bad and the Ugly | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > The Good, the Bad and the Ugly
Sparse neural retrieval is not so well known, as opposed to methods it's based on -- term-based and dense retrieval. Their weaknesses motivated this field's development, guiding its evolution. Let's follow its path. | [
0.03436897695064545,
-0.024458155035972595,
-0.028851443901658058,
-0.04042394831776619,
0.04215594381093979,
-0.07554520666599274,
0.0745517909526825,
0.0372212678194046,
0.07617633044719696,
-0.01509987935423851,
0.014648419804871082,
0.051523156464099884,
0.053949639201164246,
0.0174226... |
698bda49-5bee-5807-8c70-08f617eea378 | /documentation/inference/matryoshka-models/ | Matryoshka Models | documentation | true | Matryoshka Models
[Matryoshka Representation Learning](https://arxiv.org/abs/2205.13147) (MRL) is a technique used to train embedding models to produce vectors that can be reduced in size with minimal loss of information. On Qdrant Cloud, for supported models, you can specify the `mrl` parameter in the `options` objec... | [
0.05200677737593651,
-0.006584516726434231,
-0.04284931719303131,
-0.05934828519821167,
0.05612122640013695,
-0.011231403797864914,
0.0840233787894249,
0.01736326888203621,
0.06718766689300537,
-0.04773619771003723,
0.04079011082649231,
0.010852662846446037,
0.04441208019852638,
-0.0433435... | |
698bfe33-7756-5e28-9cc5-5ace22782df1 | /documentation/edge/edge-api/updating-data/ | Updating Data | Update Operations > Modify the Vector Schema | documentation | false | Updating Data > Update Operations > Modify the Vector Schema
Add or remove named vectors to an existing Edge Shard’s schema. This is useful when migrating to a new embedding model or adding hybrid search to an Edge Shard that already contains data.
| Operation | Parameters | Description |
| --- | --- | --- |
| `creat... | [
0.05583413690328598,
-0.03993714973330498,
-0.05851362645626068,
-0.029916249215602875,
0.06072006747126579,
-0.018027065321803093,
0.061647869646549225,
0.052923783659935,
0.04364141821861267,
-0.036037296056747437,
0.04646044224500656,
0.045880936086177826,
0.03635193780064583,
-0.016547... |
6994f277-d76e-599f-807a-b47fca3ac69a | /course/essentials/day-1/movie-search-system/ | Demo: Semantic Movie Search | Step 5: Comparing Search Results | course | true | Demo: Semantic Movie Search > Step 5: Comparing Search Results
Now comes the fascinating part: testing how different chunking strategies affect search quality. Let's create a helper function to compare results:
```python
def search_and_compare(query, k=3):
"""Compare search results across all three chunking strat... | [
0.04621679708361626,
-0.08418169617652893,
-0.059283290058374405,
-0.011004878208041191,
0.04717404767870903,
-0.02327152155339718,
0.051472630351781845,
0.008385294117033482,
0.10636826604604721,
-0.019707510247826576,
0.05687844753265381,
0.031735654920339584,
0.06732446700334549,
-0.040... |
699dae82-38ac-52ab-82dc-5cd2429cd90e | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Implementing Vector Search with Reranking > Implementation > Upsert Data | documentation | true | Reranking for Better Search > Implementing Vector Search with Reranking > Implementation > Upsert Data
We need to transform those dense embeddings into a format Qdrant can work with, and that’s where Points come in. Points are the building blocks of Qdrant—they’re records made up of a vector (the embedding) and an opt... | [
0.059583667665719986,
-0.06065953150391579,
-0.055277835577726364,
-0.011043121106922626,
0.06658390909433365,
-0.042907021939754486,
0.053176574409008026,
0.04864201694726944,
0.08434779942035675,
-0.01803988218307495,
0.020938612520694733,
0.013265863992273808,
0.03952756151556969,
-0.00... |
69a31b86-3440-5a35-8005-f3a4cbe983f8 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Where Scalar Quantization Fits Today > Accessing Best Practices | article | false | Scalar Quantization for Vector Search > Where Scalar Quantization Fits Today > Accessing Best Practices
Qdrant documentation on [Scalar Quantization](/documentation/manage-data/quantization/#setting-up-quantization-in-qdrant)
is a great resource describing different scenarios and strategies to achieve up to 4x
lower ... | [
0.04155656695365906,
-0.03145226091146469,
-0.046434346586465836,
-0.05025044456124306,
-0.0019169431179761887,
-0.014263720251619816,
0.053309500217437744,
0.03133261203765869,
0.11876703798770905,
-0.04561711475253105,
0.008507689461112022,
-0.004572208039462566,
0.03086142987012863,
-0.... |
69c68add-f139-523e-bd9f-95981eb41cc1 | /documentation/installation/ | Installation | Installation options | documentation | false | Installation > Installation options
Qdrant can be installed in different ways depending on your needs:
For production, you can use our Qdrant Cloud to run Qdrant either fully managed in our infrastructure or with Hybrid Cloud in yours.
If you want to run Qdrant in your own infrastructure, without any cloud connectio... | [
0.009421383030712605,
-0.04139954596757889,
-0.05914922431111336,
-0.05084711313247681,
0.023977823555469513,
-0.040043577551841736,
0.07686135172843933,
0.03852958232164383,
0.07839259505271912,
-0.013948776759207249,
0.020511530339717865,
0.012839817441999912,
0.07726407051086426,
-0.033... |
69d1fb1d-b3ef-59b1-b8c6-6cc0c5ea2e8d | /articles/search-feedback-loop/ | Relevance Feedback in Information Retrieval | Query Refinement > Query As Text | article | false | Relevance Feedback in Information Retrieval > Query Refinement > Query As Text
1. Get pseudo-relevance feedback from the finetuned BERT reranker (~10 documents);
2. Chunk these pseudo-relevant documents (~100 words) and score query-chunk relevance with the same reranker;
3. Expand the query with the most relevant chun... | [
0.040674593299627304,
-0.05419575423002243,
-0.06827739626169205,
-0.05493590235710144,
0.06755974888801575,
-0.0326969251036644,
0.042432092130184174,
0.0234236940741539,
0.0850098505616188,
-0.007309689652174711,
0.031095663085579872,
0.0062814014963805676,
0.06655985116958618,
-0.056523... |
69d90475-5092-5fc6-8aca-831f1de2d2b9 | /documentation/production-operations/bulk-data-import/ | Bulk Uploading Data to Qdrant | Throughput Choices | documentation | false | Bulk Uploading Data to Qdrant > Throughput Choices
The options above depend on your vector type, memory limits, and search needs. Batching, parallelism, and sharding change how fast data gets in. Batching helps almost every upload. Parallelism and sharding are workload choices: they help when a single upload stream ca... | [
0.0031889176461845636,
-0.03602471202611923,
-0.05083296447992325,
-0.03855102136731148,
0.0860787183046341,
-0.02267950028181076,
0.08847179263830185,
0.008601661771535873,
0.08659660071134567,
-0.033970125019550323,
0.01829317957162857,
0.03213665634393692,
0.025950536131858826,
-0.02404... |
69e16e73-92ce-51a8-8ae6-0d02dcd4b5a1 | /articles/triplet-loss/ | Advanced Introduction to Triplet Loss | What is Triplet Loss? | article | false | Advanced Introduction to Triplet Loss > What is Triplet Loss?
Triplet Loss was first introduced in [FaceNet: A Unified Embedding for Face Recognition and Clustering](https://arxiv.org/abs/1503.03832) in 2015,
and it has been one of the most popular loss functions for supervised similarity or metric learning ever since... | [
0.06800207495689392,
-0.03837449103593826,
-0.023439180105924606,
-0.018696317449212074,
0.04628694802522659,
0.03237209469079971,
0.016441214829683304,
0.039543893188238144,
0.051792167127132416,
-0.03746612370014191,
0.01840272918343544,
-0.0017038689693436027,
0.011211092583835125,
-0.0... |
69fecd66-c2b1-5ecf-885b-287a2d846bd3 | /documentation/ops-optimization/optimize/ | Optimize Performance | 2. High Precision with Low Memory Usage | documentation | true | Optimize Performance > 2. High Precision with Low Memory Usage
If you require high precision but have limited RAM, you can store both vectors and the HNSW index on disk. This setup reduces memory usage while maintaining search precision.
To move the vectors to the `cold` [memory tier](/documentation/ops-configuration... | [
0.02562926709651947,
-0.04846200346946716,
-0.023637354373931885,
-0.020954381674528122,
0.046018335968256,
-0.015949741005897522,
0.051978278905153275,
0.026218805462121964,
0.0856248065829277,
-0.011164190247654915,
-0.011042465455830097,
0.02598472870886326,
0.05717700719833374,
-0.0180... |
6a043b1a-fcd0-5edf-93ea-30a01e70b58e | /documentation/capacity-planning/ | Capacity Planning | Calculating RAM and Disk Size > Payloads | documentation | true | Capacity Planning > Calculating RAM and Disk Size > Payloads
#### Payload Storage
Each point can carry a [payload](/documentation/manage-data/payload/), arbitrary JSON data stored alongside the vector. Its size depends entirely on the [structure and content of your data](/documentation/manage-data/payload/#payload-ty... | [
0.00877553690224886,
-0.02298550494015217,
-0.04703391715884209,
-0.05759890377521515,
0.04422692582011223,
-0.017713850364089012,
0.04583558440208435,
0.01796833612024784,
0.09344267100095749,
-0.03335301950573921,
0.026665715500712395,
-0.01027775090187788,
0.031174974516034126,
-0.01212... |
6a0fad32-0aa2-59f6-a751-5b13658781b8 | /articles/gridstore-key-value-storage/ | Introducing Gridstore: Qdrant's Custom Key-Value Store | Gridstore in Production: Maintaining Data Integrity > When Things Break in Real Life | article | false | Introducing Gridstore: Qdrant's Custom Key-Value Store > Gridstore in Production: Maintaining Data Integrity > When Things Break in Real Life
Real-world systems don’t operate in a vacuum. Failures happen: software bugs cause unexpected crashes, memory exhaustion forces processes to terminate, disks fail to persist dat... | [
0.04801531508564949,
-0.020539551973342896,
-0.05721556022763252,
-0.03087218664586544,
0.07788839936256409,
-0.018646148964762688,
0.045033495873212814,
0.01411439012736082,
0.07214364409446716,
-0.006034186575561762,
0.003746270900592208,
0.005713639780879021,
0.06064305454492569,
-0.015... |
6a2a325f-a4fb-5db5-ad7d-d6505d46e95a | /documentation/cloud-rbac/permission-reference/ | Permission Reference | Cluster > API Keys | documentation | false | Permission Reference > Cluster > API Keys
| Permission | Description |
|------------|------------|
| `read:api_keys` | View Database API Keys for Managed Cloud clusters. |
| `write:api_keys` | Create new Database API Keys for Managed Cloud clusters. |
| `delete:api_keys` | Remove Database API Keys for Managed Cloud cl... | [
0.013385636731982231,
-0.006233104970306158,
-0.06356851756572723,
-0.059263065457344055,
0.04313424602150917,
-0.029795564711093903,
0.01430877298116684,
0.06723039597272873,
0.05868719890713692,
-0.051462069153785706,
0.03161114081740379,
0.016878264024853706,
0.06633105129003525,
-0.018... |
6a31049f-dff8-54aa-9e70-351a0c9e6064 | /articles/what-is-a-vector-database/ | What is a Vector Database? | Distributed Deployment | article | false | What is a Vector Database? > Distributed Deployment
When thinking about scaling, the key factors to consider are **fault tolerance**, **load balancing**, and **availability**. One node, no matter how powerful, can only take you so far. Eventually, you'll need to spread the workload across multiple machines to ensure t... | [
0.0005641329917125404,
-0.045469045639038086,
-0.06493639945983887,
-0.04570676386356354,
0.0613708533346653,
-0.044455453753471375,
0.060527946799993515,
0.024701951071619987,
0.08962157368659973,
0.012514768168330193,
0.041077230125665665,
0.008741326630115509,
0.056501757353544235,
-0.0... |
6a35a6c9-4c38-5e6c-a059-4acb4c43be0f | /documentation/migrate-to-qdrant/from-azure-search/ | From Azure AI Search | Concept Mapping | documentation | false | From Azure AI Search > Concept Mapping
| Azure AI Search | Qdrant | Notes |
| :--- | :--- | :--- |
| Index | Collection | One-to-one mapping |
| Document | Point | Each document becomes a point |
| Vector field (`Collection(Edm.Single)` with `dimensions`) | Named vector | Each vector field in the index becomes a named... | [
0.06696372479200363,
-0.041611235588788986,
-0.0453992560505867,
-0.054466377943754196,
0.08113214373588562,
-0.017892638221383095,
0.045284196734428406,
0.04715704917907715,
0.06620512157678604,
-0.046708784997463226,
0.042582109570503235,
0.015924984589219093,
0.03744978457689285,
-0.022... |
6a476792-95fb-5bde-86bd-db5365b57656 | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | Different search modes > Cold start | documentation | false | Multimodal Food Search Demo > Different search modes > Cold start
Recommendation systems struggle with a cold start problem. When a new user joins the system, there is no data about their preferences, so it’s hard to recommend
anything. The same applies to our demo. When you open it, you will see a random selection of... | [
0.033126410096883774,
-0.05861751735210419,
-0.041631314903497696,
-0.03886384516954422,
0.09397944808006287,
-0.010189659893512726,
0.07675739377737045,
0.0365738719701767,
0.07999784499406815,
0.007868153974413872,
0.01606217585504055,
0.04665548726916313,
0.05452471226453781,
-0.0319561... |
6a4ee7e7-923b-57a5-b732-63db7dcce422 | /documentation/cloud-pricing-payments/ | Billing & Payments | Billing > GCP Marketplace | documentation | false | Billing & Payments > Billing > GCP Marketplace
Our [GCP Marketplace](https://console.cloud.google.com/marketplace/product/qdrant-public/qdrant) listing streamlines access to Qdrant for users who rely on the Google Cloud Platform for hosting and application development.
To subscribe:
1. Go to Billing Details screen i... | [
0.006690450012683868,
-0.011162180453538895,
-0.03911587968468666,
-0.021204061806201935,
0.0626320168375969,
-0.037784598767757416,
0.07384700328111649,
0.08202192187309265,
0.08321759104728699,
-0.041707564145326614,
0.07531893998384476,
0.006488645914942026,
0.049880966544151306,
-0.037... |
6a689f30-9269-5d85-b022-13a3a0059365 | /documentation/edge/edge-bm25/ | BM25 | Configure a Sparse Vector | documentation | true | BM25 > Configure a Sparse Vector
To get started with BM25, create an Edge Shard with a sparse vector field and `Modifier.Idf`. The IDF modifier enables inverse document frequency weighting, which is required for BM25 scoring:
```python
from qdrant_edge import (
EdgeConfig,
EdgeShard,
EdgeSparseVectorParam... | [
0.061555929481983185,
-0.025798851624131203,
-0.010132363066077232,
-0.06683877110481262,
0.051446057856082916,
-0.03573846444487572,
0.06907998025417328,
0.042991701513528824,
0.045989200472831726,
-0.013188617303967476,
0.03109656646847725,
0.011244254186749458,
0.03516070544719696,
-0.0... |
6a791f3d-b74e-5902-ac49-ea4544e87394 | /documentation/search-tuning/when-your-collection-outgrows-ram/ | When Your Collection Outgrows RAM | If TurboQuant Is Not the Right Fit | documentation | false | When Your Collection Outgrows RAM > If TurboQuant Is Not the Right Fit
For a comparison of TurboQuant bit depths across ten datasets, see [TurboQuant in Qdrant](/articles/turboquant-quantization/). Qdrant also supports [Scalar, Binary, and Product Quantization](/documentation/manage-data/quantization/), and each one v... | [
0.040885522961616516,
-0.04242250695824623,
-0.03955046832561493,
-0.041251469403505325,
0.03245467692613602,
-0.019230054691433907,
0.08679851144552231,
0.03313729912042618,
0.1066175252199173,
-0.02499128133058548,
0.059611380100250244,
0.03508111834526062,
0.03340722247958183,
-0.006575... |
6a7d0d08-00c3-5f79-8017-4b3fad101355 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 2. How do I Ingest and Index Large Amounts of Data? > Other Solutions to Alleviate Indexing Bottleneck | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 2. How do I Ingest and Index Large Amounts of Data? > Other Solutions to Alleviate Indexing Bottleneck
**Increase indexing threads:** If you're using more than 16 cores, consider explicitly increasing the number of indexing threads.
> By default, Qdrant uses u... | [
-0.004335474222898483,
-0.03770461305975914,
-0.08703075349330902,
-0.02276725508272648,
0.058790117502212524,
-0.03768464922904968,
0.02804580330848694,
0.01974373683333397,
0.1061449944972992,
-0.03247445449233055,
0.02665904350578785,
0.006296518724411726,
0.0352652408182621,
-0.0500581... |
6a8741ce-24c9-50d4-9f05-6bc9e5705efe | /documentation/cloud/cluster-monitoring/ | Monitor Clusters | Alerts | documentation | false | Monitor Clusters > Alerts
If you are still using the key, you can create a new Database API Key and update your application to use the new one.
**Where can I learn more about this alert?**
Learn about the SDKs [here](/documentation/interfaces/).
Learn more about JWT Keys and permissions [here](/documentation/securi... | [
0.00950977485626936,
-0.01932561583817005,
-0.07322632521390915,
-0.02218545600771904,
0.04938565939664841,
-0.018876831978559494,
0.03754867985844612,
0.039016418159008026,
0.08547256886959076,
-0.05568520724773407,
0.024155281484127045,
0.008200832642614841,
0.04441023990511894,
-0.03806... |
6aad4bf4-e361-57c0-8fbf-0ce855c7e3ce | /documentation/ops-configuration/usage-statistics/ | Usage Statistics | What information is collected? | documentation | false | Usage Statistics > What information is collected?
There are 3 types of information that we collect:
* System information - general information about the system, such as CPU, RAM, and disk type. As well as the configuration of the Qdrant instance.
* Performance - information about timings and counters of various piece... | [
0.02519598789513111,
-0.05381247401237488,
-0.024850454181432724,
-0.021078569814562798,
0.057081472128629684,
-0.04281838238239288,
0.045128580182790756,
0.05330017954111099,
0.12214475125074387,
-0.055603645741939545,
0.01931377686560154,
0.024114619940519333,
0.06752578914165497,
-0.040... |
6ab0f006-be86-5098-840d-9badb20abc9b | /documentation/web-ui/ | Qdrant Web UI | documentation | false | Qdrant Web UI
You can manage both local and cloud Qdrant deployments through the Web UI.
If you've set up a deployment locally with the Qdrant [Quickstart](/documentation/quickstart/),
navigate to http://localhost:6333/dashboard.
If you've set up a deployment in a cloud cluster, find your Cluster URL in your
cloud d... | [
0.0264652781188488,
-0.031755708158016205,
-0.009928318671882153,
-0.022241154685616493,
0.05549805611371994,
-0.03245183825492859,
0.07420297712087631,
0.03395511582493782,
0.05374690890312195,
-0.047983452677726746,
0.032331909984350204,
0.058847103267908096,
0.023068305104970932,
-0.011... | |
6ade18c2-a175-56d7-b8fd-4029cb64fb09 | /documentation/search-tuning/when-a-reranker-is-worth-it/ | When Is a Reranker Worth It? | documentation | false | When Is a Reranker Worth It?
Note: The measurements in this article use five public datasets chosen to vary in corpus size, document and query shape, and relevance task, so read these reranker deltas as directional. They range from 5,183 to 100,000 documents, and each collection was built in one batch on one shard, un... | [
0.02192951738834381,
-0.03124893270432949,
-0.05917414650321007,
-0.04670952633023262,
0.04843860864639282,
-0.0718972310423851,
0.028783908113837242,
0.06347435712814331,
0.08944344520568848,
-0.027141746133565903,
0.029781006276607513,
0.02850215695798397,
0.03913126885890961,
-0.0219072... | |
6ae93ec6-b067-571f-9053-e73489b134ac | /documentation/edge/edge-api/reading-data/ | Reading Data | query | documentation | false | Reading Data > query
| Kind | Purpose |
| --- | --- |
| `Query` | Vector similarity: nearest neighbor, recommendation, discovery, context, or feedback. |
| `Fusion` | Combine the results of multiple prefetches. Refer to [Hybrid Queries](/documentation/search/hybrid-queries/). |
| `OrderBy` | Order by a payload field i... | [
0.052910950034856796,
-0.052475422620773315,
-0.05157715082168579,
-0.04104858636856079,
0.0746527835726738,
-0.003333158092573285,
0.06064187362790108,
0.017208004370331764,
0.06015118956565857,
-0.02136313170194626,
0.03651824966073036,
0.012881793081760406,
0.05217783898115158,
0.019062... |
6aee2159-81b2-5023-8562-f576a60e6346 | /course/multi-vector-search/module-3/evaluating-pipelines/ | Evaluating Search Pipelines | Putting It All Together | course | true | Evaluating Search Pipelines > Putting It All Together
Here's the complete evaluation workflow:
```python
from fastembed import LateInteractionMultimodalEmbedding
from fastembed.postprocess import Muvera
from ranx import Qrels, Run, compare
import numpy as np
# 1. Load model and initialize MUVERA
model = LateInteract... | [
0.032866425812244415,
-0.002094854135066271,
-0.05303368717432022,
-0.05822153761982918,
0.08109179884195328,
-0.013381491415202618,
0.033420056104660034,
-0.0027319854125380516,
0.046773504465818405,
-0.0005040574469603598,
0.021144147962331772,
0.017468903213739395,
0.07435426115989685,
... |
6af0a7bb-98b1-50b5-b8f7-bea794dfe1a4 | /documentation/tutorials-operations/data-streaming-kafka-qdrant/ | Kafka Streaming into Qdrant | Playground Application | documentation | true | Kafka Streaming into Qdrant > Playground Application
With the infrastructure set up, create a simple application to check it. The application inserts data into MongoDB, and the connector then ingests it into Qdrant through [Change Data Capture (CDC)](https://www.confluent.io/learn/change-data-capture/).
`requirements... | [
0.0318138487637043,
-0.06402037292718887,
-0.020881524309515953,
-0.02141784131526947,
0.05896120145916939,
-0.03239419311285019,
0.09779311716556549,
0.0847645029425621,
0.04543544352054596,
-0.012767392210662365,
-0.01789112575352192,
0.01790017820894718,
0.025983436033129692,
-0.0359533... |
6af7ffc1-0175-5acd-bb1b-9000af7ab882 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Use Labels to Choose a k Range | documentation | false | How to Tune Hybrid Search in Qdrant > Use Labels to Choose a k Range
| Dataset | Queries | Relevant per Query | k=1 | k=2 | k=5 | k=20 | k=61 |
|---|---|---|---|---|---|---|---|
| ArguAna | 1,401 | 1.0 | 0.5171 | 0.5216 | 0.5304* | 0.5269 | 0.5207 |
| CodeSearchNet | 1,000 | 1.0 | 0.6501 | 0.6555 | 0.6580* | 0.6511 | ... | [
0.043445929884910583,
-0.024945586919784546,
-0.08242293447256088,
-0.016469473019242287,
0.061021264642477036,
-0.05364496260881424,
0.05112389847636223,
0.05601826310157776,
0.06828150153160095,
-0.04251503944396973,
0.02314011938869953,
-0.010907137766480446,
0.05769765004515648,
-0.041... |
6af81ce9-ab2e-5c48-916d-d8d28b7c836b | /documentation/tutorials-operations/time-based-sharding/ | Time-Based Sharding | Ingest New Data | documentation | true | Time-Based Sharding > Ingest New Data
When ingesting new data, set the `shard_key_selector` to today's date, using the `today` value defined in the pruning step, so the data goes to the correct shard:
```python
client.upsert(
collection_name=collection_name,
points=[PointStruct(
id=uuid.uuid4().hex,
... | [
0.01690015010535717,
-0.04561914876103401,
-0.03852635622024536,
-0.05038273334503174,
0.015303482301533222,
-0.05280826985836029,
0.01094700489193201,
0.026366280391812325,
0.029115552082657814,
-0.018507005646824837,
0.022662365809082985,
0.01943313702940941,
0.0701192319393158,
-0.04399... |
6af9a4a3-7a53-5636-8d49-1f2a81a99bb2 | /course/multi-vector-search/module-1/use-cases-multi-vector/ | Use Cases for Multi-Vector Search | A Concrete Demonstration > The Scenario: A Technical Support Query | course | true | Use Cases for Multi-Vector Search > A Concrete Demonstration > The Scenario: A Technical Support Query
Consider a developer searching for a specific technical solution:
```python
query = "How can I prevent Python database connection " \
"pool exhaustion in async web applications?"
```
This query has multiple... | [
0.017790643498301506,
-0.08214878290891647,
-0.05986721068620682,
-0.0389009565114975,
0.02198965847492218,
-0.013203372247517109,
0.053683068603277206,
-0.020825279876589775,
0.08739759773015976,
-0.00944727286696434,
-0.007346694823354483,
0.008315544575452805,
0.04919621720910072,
-0.01... |
6b177539-897f-5e76-bab6-70701d8ffa5d | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > StorageClassNames | documentation | false | API Reference > qdrant.io/v1 > Resource Types > StorageClassNames
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `db` _string_ | DB specifies the storage class name for db volume. | | Optional: \{\} |
| `snapshots` _string_ | Snapsh... | [
0.02607913874089718,
-0.026653952896595,
0.005276944488286972,
-0.06975532323122025,
0.027594348415732384,
-0.05561119318008423,
0.06168648600578308,
0.05819876492023468,
0.034791287034749985,
-0.04099281132221222,
0.04897019639611244,
0.011366402730345726,
0.05539345368742943,
-0.00135869... |
6b17cf7d-f1ec-57b9-99c4-1bc1f03d7aa8 | /course/essentials/day-7/jina/ | Integrating with Jina AI | Jina AI Multimodal Embeddings | course | false | Integrating with Jina AI > Jina AI Multimodal Embeddings
Jina AI provides state-of-the-art deep neural networks for transforming text and images into high-quality vector representations. The Jina Embeddings v4 model represents a breakthrough in multimodal embedding technology, enabling seamless integration of text and... | [
0.05867140740156174,
-0.03592284396290779,
-0.056692175567150116,
-0.04371195286512375,
0.060665689408779144,
0.006296234205365181,
0.08994267880916595,
0.05963437631726265,
0.03549960255622864,
0.0008896788349375129,
0.05772643908858299,
-0.007708401884883642,
0.05200542137026787,
-0.0410... |
6b1cff17-93d9-537b-a3d2-e83e892694e7 | /documentation/cloud-rbac/permission-reference/ | Permission Reference | Cluster > Backups | documentation | false | Permission Reference > Cluster > Backups
| Permission | Description |
|------------|------------|
| `read:backups` | View backups in the **Backups page** and **Cluster details > Backups tab**. |
| `write:backups` | Create backups from the **Backups page** and **Cluster details > Backups tab**. |
| `delete:backups` | R... | [
0.026465188711881638,
-0.0187204759567976,
-0.0631859079003334,
-0.06254182755947113,
0.06977818161249161,
-0.0044711981900036335,
-0.007964324206113815,
0.05731462687253952,
0.07007797062397003,
-0.022340361028909683,
0.05501146242022514,
0.012975279241800308,
0.0811702236533165,
-0.04052... |
6b25c8f1-4af1-5989-9b0e-5e4b9fb156ba | /documentation/tutorials-operations/blue-green-deployment/ | Blue-Green Cluster Deployment | Step 2: Load Data into the New Cluster > Option D: Restore from a Volume Backup | documentation | false | Blue-Green Cluster Deployment > Step 2: Load Data into the New Cluster > Option D: Restore from a Volume Backup
If you take disk-level backups of the Qdrant storage volume, for example, EBS snapshots on AWS, persistent disk snapshots on GCP, or equivalent block storage snapshots on other platforms, [you can restore on... | [
0.032671958208084106,
-0.041550762951374054,
0.003827968379482627,
-0.07189300656318665,
0.07154835760593414,
-0.04122374206781387,
0.058670155704021454,
0.027828164398670197,
0.04903298243880272,
-0.029310518875718117,
0.01360356155782938,
0.030509211122989655,
0.030481848865747452,
-0.02... |
6b6c97c6-19fc-543f-99b5-9678a9e36b8a | /course/beginners/module-2/core-data-model/ | Core Data Model | Creating a Collection | course | true | Core Data Model > Creating a Collection
Once connected, you create a collection by setting two parameters: the size of the vectors it accepts and the distance metric used for similarity.
Both come from your embedding model. 384 is the vector size of all-MiniLM-L6-v2, the model from Module 1, and cosine is the metric ... | [
0.03234999626874924,
-0.033019546419382095,
-0.037950217723846436,
-0.04335275664925575,
0.05670985206961632,
-0.039886608719825745,
0.054733939468860626,
0.10333671420812607,
0.10599157214164734,
-0.04056405648589134,
0.040192827582359314,
0.015644339844584465,
0.021788885816931725,
0.001... |
6b6e3521-a531-5e9b-b37a-b72d4a6e2fa2 | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Replication | documentation | true | Distributed Deployment > Replication
Shards can be [replicated](/documentation/scaling/horizontal-scaling/#replication) between nodes in the cluster, keeping several copies of a shard spread across the cluster. This enables you to scale your read throughput and tolerate node failures.
### Replication Factor
When you... | [
-0.002932504750788212,
-0.028553783893585205,
-0.06854388862848282,
-0.031340908259153366,
0.08493700623512268,
-0.037274692207574844,
0.044079165905714035,
0.04769201949238777,
0.05988239869475365,
-0.053631410002708435,
0.013931307010352612,
0.01354293990880251,
0.03701407462358475,
-0.0... |
6b7d17c1-cb71-5db5-8955-48f14a51beea | /documentation/snapshots/ | Snapshots | Storage > S3 | documentation | true | Snapshots > Storage > S3
*Available as of v1.10.0*
Rather than storing snapshots on the local file system, you may also configure
to store snapshots in an S3-compatible storage service. To enable this, you must
configure it in the [configuration](/documentation/ops-configuration/configuration/) file.
For example, to... | [
-0.0009169467375613749,
-0.016309358179569244,
-0.01541533600538969,
-0.05234313756227493,
0.01693308725953102,
-0.05437163636088371,
0.024279795587062836,
0.015203808434307575,
0.03650682792067528,
-0.02355990558862686,
0.01609216257929802,
0.010005449876189232,
0.08310946077108383,
-0.01... |
6b828259-92fb-5b65-a481-ad10699ad140 | /articles/what-is-rag-in-ai/ | Understanding Retrieval-Augmented Generation (RAG) | Build Your First RAG App | article | false | Understanding Retrieval-Augmented Generation (RAG) > Build Your First RAG App
[5-Minute RAG with DeepSeek](/documentation/tutorials-build-essentials/rag-deepseek/) builds a complete pipeline with Qdrant: it embeds a small knowledge base with FastEmbed, retrieves the facts relevant to a question, and passes them to an ... | [
0.030482303351163864,
-0.04330694302916527,
-0.03448246419429779,
-0.04748789221048355,
0.08309488743543625,
-0.02865399420261383,
0.061257388442754745,
0.04451029747724533,
0.04390740767121315,
-0.05404847860336304,
0.014288945123553276,
0.02555805817246437,
0.058512765914201736,
-0.02596... |
6bb41cc3-0055-5fc4-8288-a32f4a03fbc8 | /documentation/security/ | Security | Authentication > Admin API Key > Enforce Authentication on Internal Communication | documentation | false | Security > Authentication > Admin API Key > Enforce Authentication on Internal Communication
- **A cluster with only `read_only_api_key` set.** The internal API accepts only read-write keys, so peers have no key to authenticate with and lose peer-to-peer communication. Qdrant logs a warning at startup, but doesn't fai... | [
0.04685988649725914,
-0.05343775451183319,
-0.06509841978549957,
-0.013327294960618019,
0.03958890587091446,
-0.016117148101329803,
0.02685600332915783,
0.05839025229215622,
0.06833554059267044,
-0.020477864891290665,
-0.0015816197264939547,
0.00607218686491251,
0.06442290544509888,
-0.037... |
6bfd55a5-8a36-5021-b5d5-b13a63becbe8 | /documentation/private-cloud/changelog/ | Changelog | 1.9.14 (2026-08-21) | documentation | false | Changelog > 1.9.14 (2026-08-21)
| Component | Version |
|-------------------------|---------|
| qdrant-kubernetes-api | v1.37.4 |
| operator | 2.34.5 |
| qdrant-cluster-manager | v0.3.22 |
| qdrant-cluster-exporter | 1.8.0 |
Latest validated Qdrant version: 1.19.0
* Improved qdrant... | [
0.05022110044956207,
-0.015181627124547958,
-0.066972516477108,
-0.034823086112737656,
0.0578148253262043,
-0.051210395991802216,
0.05971108004450798,
0.03704040125012398,
0.053130149841308594,
-0.03513065725564957,
0.04194393381476402,
0.040466777980327606,
0.0532817579805851,
-0.06503964... |
6c084bb3-cae3-5073-88cc-9233480abe40 | /course/multi-vector-search/module-3/multi-stage-retrieval/ | Multi-Stage Retrieval with Universal Query API | Implementing Multi-Stage Retrieval in Qdrant > Basic Example: Single-Vector to ColBERT | course | true | Multi-Stage Retrieval with Universal Query API > Implementing Multi-Stage Retrieval in Qdrant > Basic Example: Single-Vector to ColBERT
Let's say you want to search for documents about "quantum computing applications" and return the top 10 results.
First, create a collection with both single-vector and multi-vector r... | [
0.045225147157907486,
-0.07100272178649902,
-0.007975494489073753,
-0.023163456469774246,
0.07154262810945511,
-0.03535071015357971,
0.08861088752746582,
0.04607623443007469,
0.05478741228580475,
-0.01487806998193264,
0.022716762498021126,
0.021858295425772667,
0.051825445145368576,
-0.078... |
6c0ac511-d74c-54aa-9a81-e4cfc1397c32 | /documentation/production-operations/bulk-data-import/ | Bulk Uploading Data to Qdrant | Throughput Choices > Batch Your Uploads | documentation | true | Bulk Uploading Data to Qdrant > Throughput Choices > Batch Your Uploads
_Dense & sparse vectors_
Each request carries overhead for the network round trip and the write path, so uploading points one at a time is slow. Upload points in batches instead.
 from startups-list.com.
- Python version >=3.9 | [
0.009132885374128819,
-0.041521213948726654,
-0.04775793477892876,
-0.01732136309146881,
0.06795243173837662,
-0.05215612053871155,
0.06318540126085281,
0.0026181242428719997,
0.06455700844526291,
-0.03585338965058327,
0.023417018353939056,
0.003925936762243509,
0.07701375335454941,
-0.043... |
6c6d9bcb-9d1d-5cd4-82e4-dd61c644d0bb | /documentation/frameworks/genkit/ | Firebase Genkit | documentation | true | Firebase Genkit
[Genkit](https://firebase.google.com/products/genkit) is a framework to build, deploy, and monitor production-ready AI-powered apps.
You can build apps that generate custom content, use semantic search, handle unstructured inputs, answer questions with your business data, autonomously make decisions, ... | [
0.011971446685492992,
-0.01379301119595766,
-0.08077501505613327,
-0.050801414996385574,
0.05932040140032768,
-0.052340347319841385,
0.05417756363749504,
0.03315006196498871,
0.029028156772255898,
-0.06586939096450806,
0.0503297820687294,
0.005852633621543646,
0.010948127135634422,
-0.0421... | |
6c7aa6a5-f406-51df-85d9-3528a0dd1b51 | /documentation/tutorials-develop/hybrid-search-fastembed/ | Build a Hybrid Search API | Deploy the search with FastAPI | documentation | true | Build a Hybrid Search API > Deploy the search with FastAPI
To build the service you will use the FastAPI framework.
1. Install FastAPI.
To install it, use the command
```bash
pip install fastapi uvicorn
```
2. Implement the service.
Create a file named `service.py` and specify the following.
The service will hav... | [
0.033699020743370056,
-0.03924174606800079,
-0.05603635683655739,
-0.011044166050851345,
0.07142781466245651,
-0.033869870007038116,
0.05642949789762497,
0.04971315339207649,
0.02259390614926815,
-0.017255358397960663,
0.047805726528167725,
0.03547843545675278,
0.06619860231876373,
-0.0330... |
6c84e72a-9a4b-51d3-bbe0-299951225c19 | /course/essentials/day-0/pitstop-project/ | Project: Building Your First Vector Search System | Share Your Discovery | course | true | Project: Building Your First Vector Search System > Share Your Discovery
### Step 1: Reflect on Your Findings
For a new concept (not the Product Categories concept) run the code above and do the following:
* **Vector Meaning:** What did each of your four dimensions represent?
* **Query & Results:** Pick one query ve... | [
0.059046421200037,
-0.08424490690231323,
-0.04635310173034668,
-0.026065541431307793,
0.0542457178235054,
-0.016124332323670387,
0.03503597900271416,
0.05412273108959198,
0.0436033234000206,
-0.030525485053658485,
0.048897553235292435,
0.03796781599521637,
0.09136222302913666,
-0.027677197... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.