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 |
|---|---|---|---|---|---|---|---|
bfa10639-d190-5940-a55f-cf4163324caf | /documentation/manage-data/multitenancy/ | Multitenancy | Partition by Payload > Per-Tenant Scoring Statistics | documentation | true | Multitenancy > Partition by Payload > Per-Tenant Scoring Statistics
*Available as of v1.19.0*
[BM25 full-text search](/documentation/search/text-search/full-text-search/) and sparse vector searches with the [IDF modifier](/documentation/manage-data/indexing/#idf-modifier), such as [miniCOIL](/documentation/search/tex... | [
0.03310286998748779,
-0.013677057810127735,
-0.042149029672145844,
-0.043026186525821686,
0.03913509100675583,
-0.022466043010354042,
0.048826996237039566,
0.023752637207508087,
0.09145763516426086,
-0.01975400373339653,
0.027979008853435516,
0.026274455711245537,
0.06341317296028137,
-0.0... |
bfa322cb-3cf5-5416-906e-1b0180b7c8e9 | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | article | true | Scalar Quantization for Vector Search
High-dimensional vector embeddings can be memory-intensive, especially when working with
large datasets consisting of millions of vectors. Memory footprint really starts being
a concern when we scale things up. A simple choice of the data type used to store a single
number impac... | [
0.06371400505304337,
-0.02890729159116745,
-0.040331725031137466,
-0.02723420225083828,
0.04890365153551102,
-0.029518701136112213,
0.03794039785861969,
0.037383291870355606,
0.12263631820678711,
-0.026007244363427162,
0.02855391800403595,
0.002748955274000764,
0.06088622286915779,
-0.0418... | |
bfa6fe4e-b156-514e-8f2f-bfdd05edf39a | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > KubernetesService | documentation | false | API Reference > qdrant.io/v1 > Resource Types > KubernetesService
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `type` _[ServiceType](https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.28/#servicetype-v1-core)_ | Type s... | [
0.05019913241267204,
-0.04006798192858696,
-0.03270578011870384,
-0.055579766631126404,
0.05399279296398163,
-0.07963323593139648,
0.07654240727424622,
0.08789833635091782,
0.060161370784044266,
-0.051782798022031784,
0.038777340203523636,
0.009616645984351635,
0.02600448578596115,
-0.0219... |
bfaacf9b-a022-5c65-b2bc-02e6b7a3186c | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | Configuring HNSW | course | false | HNSW Indexing Fundamentals > Configuring HNSW
We can fine-tune how our HNSW graph is built to balance search speed, accuracy, memory usage, and indexing time, depending on our use case needs. Qdrant allows you to control how the HNSW index behaves with three key parameters: `m`, `hnsw_ef`, and `ef_construct`. | [
0.030163470655679703,
-0.03066277503967285,
-0.053795889019966125,
-0.01730012334883213,
0.023945041000843048,
-0.05183986946940422,
0.07279188185930252,
0.06911328434944153,
0.0872245728969574,
-0.00619844812899828,
0.02030826546251774,
0.02583085186779499,
0.0855446308851242,
-0.02426696... |
bfef51f9-b014-5189-b910-531bebf6a96e | /documentation/tutorials-build-essentials/data-ingestion-beginners/ | S3 Ingestion | Step 4: Create the Collection | documentation | true | S3 Ingestion > Step 4: Create the Collection
Each product has two representations, so the collection holds two [named vectors](/documentation/manage-data/vectors/#named-vectors):
| Vector | Model | Dimensions |
| --- | --- | --- |
| `text_embedding` | [`sentence-transformers/all-MiniLM-L6-v2`](https://huggingface.co/... | [
0.03893424570560455,
-0.04662551358342171,
-0.029596388339996338,
-0.0389791801571846,
0.0611598901450634,
-0.031863000243902206,
0.04390854388475418,
0.08032248914241791,
0.06134553253650665,
-0.008513625711202621,
0.03054814413189888,
0.02544143795967102,
0.08136716485023499,
-0.03989246... |
c00c6b72-905a-508e-bcb0-e6b635ed7052 | /documentation/migrate-to-qdrant/from-redis/ | From Redis | What You Need from Redis | documentation | false | From Redis > What You Need from Redis
- **Redis address** — host and port of your Redis instance
- **FT index name** — the RediSearch full-text index that contains your vectors
- **Authentication** — username and password, if configured
Important: Redis does not expose vector configurations (dimensions, distance metr... | [
0.02879360131919384,
-0.039298079907894135,
-0.02966836467385292,
-0.03011339157819748,
0.05119708552956581,
-0.046577271074056625,
0.050227969884872437,
0.04475785791873932,
0.08164633810520172,
-0.049615904688835144,
0.04644644632935524,
0.008071322925388813,
0.05139092728495598,
-0.0451... |
c01e2e66-2d99-527e-a49b-ad10a0be5752 | /documentation/tutorials-develop/neural-search/ | Build a Semantic Search API | Deploy the Search with FastAPI | documentation | true | Build a Semantic 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 h... | [
0.037756018340587616,
-0.044158436357975006,
-0.028209036216139793,
0.004598306491971016,
0.0785018801689148,
-0.039312344044446945,
0.057359479367733,
0.03067512810230255,
0.023918701335787773,
-0.02960859052836895,
0.06392894685268402,
0.046305567026138306,
0.06180046126246452,
-0.041034... |
c033a671-a8f5-5efd-9335-ace48cec7d69 | /documentation/security/ | Security | Authentication > Granular Access API Keys | documentation | true | Security > Authentication > Granular Access API Keys
*Available as of v1.9.0*
Granular access API keys let you assign read or write permissions on individual collections, enabling [Role-based access control (RBAC)](https://en.wikipedia.org/wiki/Role-based_access_control). They're built on the [JSON Web Tokens (JWT)](... | [
0.0075272368267178535,
-0.019196592271327972,
-0.03995439410209656,
-0.06769080460071564,
0.054341282695531845,
-0.0577591136097908,
0.06162819638848305,
0.07676257193088531,
0.051353491842746735,
-0.04241346940398216,
0.048391856253147125,
0.056358493864536285,
0.05522123724222183,
-0.029... |
c0707b33-116f-5f48-9610-8d0d33333ec2 | /documentation/production-operations/predictable-search-latency/ | Configure Qdrant's Optimizer for Predictable Search Latency | documentation | false | Configure Qdrant's Optimizer for Predictable Search Latency
A bulk load finishes, and the collection looks ready: every point is in, and the upload call has returned. Then the first queries land, and search takes hundreds of milliseconds, sometimes several seconds at a stretch, while Qdrant's indexing, merge, and vacu... | [
0.008730310015380383,
-0.039679091423749924,
-0.06195254251360893,
-0.02409621886909008,
0.07651641964912415,
-0.05131965130567551,
0.040010642260313034,
0.018741222098469734,
0.10105156153440475,
-0.05516831949353218,
0.031142525374889374,
0.007035099435597658,
0.05436847731471062,
-0.040... | |
c0714fcf-3521-5d38-975a-3aff6fbe05c2 | /documentation/embeddings/gemini/ | Gemini | Models | documentation | false | Gemini > Models
| Model | Dimensions | Max Input Tokens | Input |
|---|---|---|---|
| `gemini-embedding-2` | 3072 (128 to 3072) | 8,192 | Text, image, video, audio, PDF |
| `gemini-embedding-001` | 3072 (128 to 3072) | 2,048 | Text |
Use `gemini-embedding-2` for new projects. `gemini-embedding-001` remains available ... | [
0.023413654416799545,
-0.00506943603977561,
-0.02867039106786251,
-0.06388434767723083,
0.04740035533905029,
-0.017659716308116913,
0.06462082266807556,
0.05940919369459152,
0.05688570439815521,
-0.07053066045045853,
0.03424137458205223,
0.029990902170538902,
0.040945179760456085,
-0.01701... |
c0793868-4ca7-59b1-95d2-fb15f0a4e886 | /documentation/search-precision/automate-filtering-with-llms/ | LLM-Powered Filter Automation | Using Instructor to generate Qdrant filters > Restricting the available fields | documentation | true | LLM-Powered Filter Automation > Using Instructor to generate Qdrant filters > Restricting the available fields
Qdrant collection info contains a list of the indexes created on a particular collection. You can use this information
to automatically determine the fields that can be used for filtering.
To follow along, c... | [
0.04714776575565338,
-0.037347421050071716,
-0.053695198148489,
-0.05906359851360321,
0.0694747120141983,
-0.01907883957028389,
0.03992760553956032,
0.02974754199385643,
0.087722048163414,
-0.041324205696582794,
0.04136461764574051,
0.03537589684128761,
0.07450534403324127,
-0.015244190581... |
c0947e3a-94e8-52c9-9608-d386cb1b0fe1 | /documentation/security/ | Security | Hardening | documentation | false | Security > Hardening
We recommend reducing the amount of permissions granted to Qdrant containers so that you can reduce the risk of exploitation. Here are some ways to reduce the permissions of a Qdrant container:
* Run Qdrant as a non-root user. This can help mitigate the risk of future container breakout vulnerabi... | [
0.03681255131959915,
-0.04074900969862938,
-0.03303929418325424,
-0.029963329434394836,
0.04690017178654671,
-0.04730017110705376,
0.06733729690313339,
0.05698978155851364,
0.06311109662055969,
-0.02064286731183529,
0.003953538369387388,
0.0007304440950974822,
0.0780942365527153,
-0.056459... |
c094a007-8128-56ac-82d2-aeaab2112615 | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | Which Framework is Best? > LangGraph | article | false | What is Agentic RAG? Building Agents with Qdrant > Which Framework is Best? > LangGraph
Each node of the process is just a Python function that does certain operation. You can call an LLM of your choice
inside of them, if you want to, but there is no assumption about the messages being created by any AI. **LangGraph ... | [
0.007711284328252077,
-0.01748381368815899,
-0.0504821315407753,
-0.015894729644060135,
0.08590003848075867,
-0.04355068877339363,
0.044467367231845856,
0.03036927618086338,
0.03451962396502495,
-0.05314597859978676,
0.03767217695713043,
-0.000145509242429398,
0.06799958646297455,
-0.01736... |
c0b151a0-ff2e-5adc-bcb9-aa557161fcf8 | /documentation/production-operations/multitenant-search/ | How to Implement Multitenancy and Custom Sharding in Qdrant | Multitenancy & custom sharding with Qdrant | documentation | false | How to Implement Multitenancy and Custom Sharding in Qdrant > Multitenancy & custom sharding with Qdrant
We have developed two major features just for this. __You can now scale a single Qdrant cluster and support all of your customers worldwide.__ Under [multitenancy](/documentation/manage-data/multitenancy/), each cu... | [
0.023886246606707573,
-0.02059285342693329,
-0.07702043652534485,
-0.02489030919969082,
0.03401414677500725,
-0.05620496720075607,
0.08194802701473236,
0.06919053196907043,
0.056657031178474426,
-0.004032686818391085,
0.026240797713398933,
0.030291857197880745,
0.08212815970182419,
-0.0163... |
c0b16956-e4fa-58a2-bb99-87eaa906019b | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | Configuring HNSW > Build Thoroughness: ef_construct | course | true | HNSW Indexing Fundamentals > Configuring HNSW > Build Thoroughness: ef_construct
The `ef_construct` parameter controls how many candidates are checked while inserting a new vector.
- Higher `ef_construct`: means more neighbors are evaluated, resulting in a more comprehensive and accurate graph. However, this also mak... | [
0.003958048298954964,
-0.045631155371665955,
-0.06263287365436554,
-0.03618588671088219,
0.007644323632121086,
-0.056770842522382736,
0.08345775306224823,
0.0771353468298912,
0.07934641093015671,
-0.03635464236140251,
0.018381725996732712,
0.024793380871415138,
0.03568635135889053,
-0.0332... |
c0bee750-9337-5d15-b7e2-987f29bea96d | /documentation/search/hybrid-queries/ | Hybrid Queries | Hybrid Search > Reciprocal Rank Fusion (RRF) > Weighted RRF | documentation | false | Hybrid Queries > Hybrid Search > Reciprocal Rank Fusion (RRF) > Weighted RRF
Retune when your retrievers change (new embedding model, new chunking), when your corpus drifts substantially, or on a fixed cadence with a fresh eval sample. | [
0.038433387875556946,
-0.024956919252872467,
-0.039332833141088486,
-0.08425091207027435,
0.055494774132966995,
-0.04912833124399185,
0.0828467383980751,
0.03573337569832802,
0.05328299105167389,
-0.031839922070503235,
0.00589641323313117,
-0.005252675618976355,
0.04539276659488678,
-0.023... |
c0c490da-a212-5f1d-a76f-116ccdcc9107 | /documentation/cloud/cluster-monitoring/ | Monitor Clusters | Grafana Dashboard > Cluster System Metrics /sys_metrics | documentation | false | Monitor Clusters > Grafana Dashboard > Cluster System Metrics /sys_metrics
In Qdrant Cloud, each Qdrant cluster will expose the following metrics. This endpoint is not available when running Qdrant open-source.
**List of metrics** | [
0.002220329362899065,
-0.00469471188262105,
-0.008695892058312893,
-0.0025177905336022377,
0.0731390193104744,
-0.04543546214699745,
0.05949819087982178,
0.05203881487250328,
0.06504400819540024,
-0.04421394318342209,
0.03781905770301819,
-0.019263576716184616,
0.0785052627325058,
-0.00543... |
c0d78623-8ae5-5472-9a91-755e25802a9e | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | Different search modes > Textual search | documentation | true | Multimodal Food Search Demo > Different search modes > Textual search
Since the demo suffers from the cold start problem, we implemented a textual search mode that is useful to start exploring the data. You can type in any text query
by clicking a search icon in the top right corner. The demo will use the CLIP model t... | [
0.03743238002061844,
-0.057493265718221664,
-0.05664835870265961,
-0.007235655095428228,
0.10901454836130142,
-0.029691539704799652,
0.07601308822631836,
0.019841300323605537,
0.032991886138916016,
0.01769074611365795,
0.02140040695667267,
0.02775006741285324,
0.054523542523384094,
-0.0372... |
c0ecc394-505b-51db-9ec0-030a8d1d020c | /documentation/scaling/vertical-scaling/ | Vertical Scaling | documentation | false | Vertical Scaling
Vertical scaling means resizing CPU, RAM, or disk on an existing node. It's simpler than horizontal scaling, avoids distributed system complexity, and is reversible, which makes it the recommended first step whenever a single node's resources are the bottleneck. | [
0.03965092450380325,
-0.011330835521221161,
-0.04708428680896759,
-0.058022115379571915,
0.09064055234193802,
-0.0003183237568009645,
0.07740308344364166,
0.04112028703093529,
0.09417202323675156,
-0.030977843329310417,
0.01064037624746561,
-0.013711808249354362,
0.038690708577632904,
0.00... | |
c0feed18-dcfb-541f-b618-1a990cf7a1e3 | /course/essentials/day-3/sparse-vectors/ | Sparse Vectors and Inverted Indexes | Sparse Vector Representations | course | true | Sparse Vectors and Inverted Indexes > Sparse Vector Representations
Sparse vectors are high dimensional vectors, filled up with zeroes except for a few dimensions. Each dimension of a sparse vector refers to a certain object, and its value – a role of this object in this sparse representation.
Let's consider a movie ... | [
0.053153738379478455,
-0.05345623940229416,
-0.04336479306221008,
-0.060794368386268616,
0.046993207186460495,
-0.029175303876399994,
0.08596466481685638,
0.047637321054935455,
0.07142379134893417,
-0.0249936543405056,
0.016367942094802856,
0.04582815244793892,
0.05778399109840393,
-0.0174... |
c124b9a8-ad64-5dff-9a8a-e7cfb653ab09 | /course/beginners/module-5/clustering-risk-signals/ | Clustering Risk Signals | Writing Cluster IDs Back to Payload | course | true | Clustering Risk Signals > Writing Cluster IDs Back to Payload
```python
from sklearn.cluster import KMeans
def cluster_and_tag(supplier_id: str, n_clusters: int = 5):
points = get_supplier_signals_last_24h(supplier_id)
ids, arr = dense_matrix(points)
if arr is None or len(ids) < n_clusters:
ret... | [
0.024917975068092346,
0.01306825503706932,
-0.06468859314918518,
-0.03424699977040291,
0.07072910666465759,
-0.044624846428632736,
0.02137765660881996,
0.07288022339344025,
0.06904183328151703,
-0.0016490573761984706,
0.0321526899933815,
0.03897636756300926,
0.037301965057849884,
-0.002502... |
c124ed0c-d1d4-51a8-a815-811ee7f9e464 | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | Step 1: Environment Setup | course | true | Demo: HNSW Performance Tuning > Step 1: Environment Setup
### Install Required Libraries
**Library purposes:**
`datasets`: Access to Hugging Face datasets, specifically our [DBpedia 100K dataset](https://huggingface.co/datasets/Qdrant/dbpedia-entities-openai3-text-embedding-3-large-1536-100K)
`qdrant-client`: Off... | [
0.04918834939599037,
-0.05852651596069336,
-0.028027161955833435,
-0.048517197370529175,
0.06803736835718155,
-0.027281858026981354,
0.05578811839222908,
0.05581223592162132,
0.04909569397568703,
-0.05486990511417389,
0.032573401927948,
0.016049223020672798,
0.057968322187662125,
-0.046523... |
c12c5a87-7e54-5e87-8885-cf2f6635fbba | /articles/universal-io/ | Universal I/O in Qdrant | Different Backends, Very Different Costs | article | false | Universal I/O in Qdrant > Different Backends, Very Different Costs
`mmap` is a solid choice for local files because you read the file as a borrowed slice of bytes (`&[u8]`), the OS keeps hot pages cached in memory, and it loads only the pages you touch. The problem was never performance, but the fact that the implemen... | [
0.04400608316063881,
-0.03720562160015106,
-0.07696017622947693,
-0.00012377992970868945,
0.07525968551635742,
-0.012562925927340984,
0.03806782513856888,
0.01205811183899641,
0.09602643549442291,
0.018642129376530647,
0.02303585223853588,
-0.0195743627846241,
0.0485466867685318,
-0.026603... |
c13e7816-346c-5417-b137-b9eb6ef08bb7 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-1/ | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS | Building the Twelve Labs Integration | documentation | true | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS > Building the Twelve Labs Integration
So how do we get video embeddings that actually understand temporal dynamics? This is where Twelve Labs comes in.
Twelve Labs provides two key models for our architecture. **Marengo** handles embeddings an... | [
0.029349036514759064,
-0.04608527198433876,
-0.10671259462833405,
-0.031036077067255974,
0.07546431571245193,
-0.029481861740350723,
0.03740939870476723,
0.030865777283906937,
0.06806009262800217,
-0.03170056641101837,
0.04134733974933624,
0.011060722172260284,
0.06129743158817291,
-0.0199... |
c1495cef-2abe-5f7b-afad-7cbdd42c82af | /articles/vector-similarity-beyond-search/ | Vector Similarity: Going Beyond Full-Text Search | Beyond Nearest-Neighbor Search | article | false | Vector Similarity: Going Beyond Full-Text Search > Beyond Nearest-Neighbor Search
Having a vector representation of unstructured data unlocks new ways of interacting with it.
For example, it can be used to measure semantic similarity between words, to cluster words or documents based on their meaning, to find related ... | [
0.052206117659807205,
-0.07778275012969971,
-0.07083874195814133,
-0.019879017025232315,
0.07914543151855469,
-0.012046586722135544,
0.0682515949010849,
0.030592920258641243,
0.02078353241086006,
0.009363105520606041,
0.04519457742571831,
0.03460191562771797,
0.06729528307914734,
0.0118272... |
c159cb9a-cecf-5832-8457-2f4892df0ebf | /documentation/production-operations/bulk-data-import/ | Bulk Uploading Data to Qdrant | Defer HNSW Indexing During Ingestion | documentation | true | Bulk Uploading Data to Qdrant > Defer HNSW Indexing During Ingestion
While you upload, the optimizer builds HNSW indexes for new segments in the background, and that work competes with ingestion for CPU and memory. If nothing needs to search the collection until the upload finishes, defer indexing: create the collecti... | [
0.022756824269890785,
-0.012160134501755238,
-0.0375339649617672,
-0.04768263176083565,
0.058452777564525604,
-0.045328591018915176,
0.023289434611797333,
0.07106786966323853,
0.08572281152009964,
-0.0312834158539772,
0.027033351361751556,
0.05551539734005928,
0.009490979835391045,
-0.0245... |
c159f99c-cdf2-574c-8ba1-522500314f4d | /course/essentials/day-1/distance-metrics/ | Distance Metrics | Quick rule of thumb > Euclidean Distance (L2 Distance) | course | true | Distance Metrics > Quick rule of thumb > Euclidean Distance (L2 Distance)
- **Common Use Cases:** Spatial data, anomaly detection, clustering.
- **Focus:** Absolute distance between points.
Euclidean distance calculates the straight-line distance between two points in multi-dimensional space. It is often used when th... | [
0.02109203115105629,
0.00043824873864650726,
-0.041600458323955536,
-0.01720902882516384,
0.04389148950576782,
-0.038904279470443726,
0.02482028305530548,
0.050151240080595016,
0.11396006494760513,
-0.023621944710612297,
0.03205092251300812,
-0.02236575447022915,
0.051916010677814484,
0.00... |
c15dcc65-ac0e-514d-893e-15364fdfc63b | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-1/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 1: Why Sparse Embeddings Beat BM25 | SPLADE: Learned Sparse Representations | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 1: Why Sparse Embeddings Beat BM25 > SPLADE: Learned Sparse Representations
SPLADE (Sparse Lexical and Expansion) is the model architecture that makes this work. It passes text through a transformer with a [masked language model](https://huggingface.co/docs/tr... | [
0.049636900424957275,
-0.05189356952905655,
-0.03408721089363098,
-0.04751262813806534,
0.05762574449181557,
-0.041671112179756165,
0.0763958990573883,
0.026832755655050278,
0.04906584694981575,
-0.013129263184964657,
0.017474260181188583,
0.015427502803504467,
0.03418024629354477,
-0.0253... |
c17aff1a-cb3d-579e-9da9-38e78c39ca96 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Best Matching 25 (BM25) > BM25 in Qdrant > BM25 in FastEmbed: Implementation Details | course | false | Demo: Keyword Search with Sparse Vectors > Best Matching 25 (BM25) > BM25 in Qdrant > BM25 in FastEmbed: Implementation Details
**Corpus Average Length**
Qdrant and FastEmbed do not compute $\mathrm{avg}_{\text{corpus}}|D|$ (the average document length in the corpus). You must **estimate and provide this value** as a... | [
0.028336601331830025,
-0.021764248609542847,
-0.014444512315094471,
-0.032632846385240555,
0.07951170951128006,
-0.03724053502082825,
0.056931111961603165,
0.020426690578460693,
0.0717402994632721,
-0.03283848986029625,
0.04619373381137848,
0.019343972206115723,
0.06506712734699249,
-0.038... |
c19b8f6b-9e86-5a1b-89aa-dcf3e62e80af | /documentation/ops-monitoring/memory-usage/ | Memory Usage | documentation | false | Memory Usage
*Available as of v1.18.0*
Qdrant lets you inspect a collection's disk space, RAM, and OS page cache usage, summed up across the whole cluster and broken down by component. Use this to plan capacity, diagnose memory pressure, or understand which parts of a collection are resident in memory.
This informat... | [
0.057183992117643356,
-0.04683513566851616,
-0.02543613314628601,
-0.04482867941260338,
0.07328616827726364,
-0.019236721098423004,
0.056006334722042084,
0.042538389563560486,
0.09164781868457794,
-0.04058118537068367,
0.005265969317406416,
0.008307237178087234,
0.06445500254631042,
-0.023... | |
c19bfaec-ac1f-5f6d-844b-8236e19c57c1 | /course/essentials/day-7/tensorlake/ | Integrating with Tensorlake | What You'll Learn | course | false | Integrating with Tensorlake > What You'll Learn
Day 7
Build scalable data lakes with vector search capabilities using TensorLake's advanced document parsing techniques.
- Data lake architecture with vectors
- Large-scale data management
- Analytics and vector search integration
- ETL pipeline optimization
- Knowledg... | [
0.031690552830696106,
-0.028939642012119293,
-0.0937969833612442,
-0.002806057222187519,
0.08968482911586761,
-0.019704801961779594,
0.039712343364953995,
0.017177129164338112,
0.025606445968151093,
-0.018645262345671654,
-0.018120508641004562,
0.033737100660800934,
0.05048924311995506,
-0... |
c1a1bc68-24b3-5a47-aabc-0cfba392354d | /documentation/tutorials-develop/code-search/ | Semantic Search for Code | Ingestion pipeline | documentation | true | Semantic Search for Code > Ingestion pipeline
Next, we'll build a pipeline for vectorizing the data and set up a semantic search mechanism for both embedding models.
### Building Qdrant collection
We use the `qdrant-client` library with the `fastembed` extra to interact with the Qdrant server and generate vector emb... | [
0.05201929435133934,
-0.04482487589120865,
-0.0297719594091177,
-0.009293110109865665,
0.07476990669965744,
-0.04278767853975296,
0.0920240506529808,
0.02849452570080757,
0.038421571254730225,
-0.008932211436331272,
0.029514072462916374,
0.03958936780691147,
0.0330331064760685,
-0.05390170... |
c1a33180-a38d-5613-b0ce-97f63c9fd6b2 | /articles/what-is-a-vector-database/ | What is a Vector Database? | Traditional Databases vs Vector Databases | article | false | What is a Vector Database? > Traditional Databases vs Vector Databases
Traditional and vector databases aren't rivals; they solve different problems. The table below shows how they compare across data structure, query method, and typical use cases.
| **Feature** | **OLTP Database** | **OLAP Database** ... | [
0.02381451055407524,
-0.06405722349882126,
-0.07256116718053818,
-0.047273557633161545,
0.025141863152384758,
-0.03479465842247009,
0.05371474474668503,
0.005086423363536596,
0.07025708258152008,
-0.010930584743618965,
0.020187903195619583,
0.02141929417848587,
0.04800913482904434,
-0.0256... |
c1a91e71-70fb-5d14-a44a-823d1fbe6017 | /articles/rag-is-dead/ | Is RAG Dead? Why Long Context Windows Don't Replace RAG | No silver bullet | article | false | Is RAG Dead? Why Long Context Windows Don't Replace RAG > No silver bullet
The LaRA benchmark reached a similar conclusion: the best choice between RAG and long context depends on the model's size and long-text ability, the context length, the task type, and the retrieved chunks. Neither approach wins everywhere.
Tha... | [
-0.006259187124669552,
-0.044721391052007675,
-0.029886361211538315,
-0.03884591907262802,
0.06908470392227173,
-0.057304080575704575,
0.03842643275856972,
0.030741794034838676,
0.08078177273273468,
-0.05106990411877632,
-0.02850358933210373,
0.006512042135000229,
0.027381135150790215,
-0.... |
c1af6097-eedb-5a6c-9538-3f121b2149b1 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Qdrant Adds > Length Renormalization | article | false | TurboQuant in Qdrant > What Qdrant Adds > Length Renormalization
Vanilla MSE has a persistent length bias: quantized vectors are systematically shorter than the originals.
The fix we use here comes from **[RaBitQ](https://arxiv.org/abs/2405.12497)** rather than from the TurboQuant paper itself: store one extra per-ve... | [
0.06115737557411194,
-0.01837661676108837,
-0.044725045561790466,
-0.053162042051553726,
0.06106659770011902,
-0.0034633646719157696,
0.03875880315899849,
0.016670113429427147,
0.092826709151268,
-0.0493941605091095,
0.01966850273311138,
-0.01999605819582939,
0.0928983986377716,
-0.0184316... |
c1ba4fdf-50b3-550b-8897-06ac419bf4d7 | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 2: Transactional Outbox Pattern > Two Worker Modes | documentation | true | Keeping Postgres and Qdrant in Sync > Tier 2: Transactional Outbox Pattern > Two Worker Modes
The implementation supports two delivery strategies:
**Polling** (default): the worker wakes up every N seconds, checks for pending events, and processes them. Simple, robust, and doesn't require a persistent database connec... | [
0.013411060906946659,
-0.031485144048929214,
-0.020407196134328842,
-0.003144641174003482,
0.02795311249792576,
-0.02719825692474842,
0.06520409882068634,
-0.026895929127931595,
0.06777121126651764,
0.033893562853336334,
0.047816138714551926,
0.04109485447406769,
0.047469887882471085,
-0.0... |
c1bbb991-2cde-5cff-a667-6393d7b318fc | /documentation/search-tuning/before-tuning-a-qdrant-collection/ | What to Check Before Tuning a Qdrant Collection | Change Things in Cost Order | documentation | false | What to Check Before Tuning a Qdrant Collection > Change Things in Cost Order
Consider a model-level rebuild only when it addresses a measured constraint, since a new embedding model means re-embedding every point. [How to choose an embedding model](/documentation/search-patterns/choose-embedding-model/) covers that d... | [
0.04816659912467003,
-0.04096577689051628,
-0.047603800892829895,
-0.03281771019101143,
0.045779671519994736,
-0.004288575146347284,
0.08900285512208939,
0.03910587728023529,
0.08096037060022354,
0.0061106267385184765,
0.04298057407140732,
-0.0046508535742759705,
0.05054640769958496,
-0.04... |
c1be2735-0e66-59d7-8539-7f4276c40109 | /documentation/migrate-to-qdrant/from-opensearch/ | From OpenSearch | Concept Mapping | documentation | false | From OpenSearch > Concept Mapping
| OpenSearch | Qdrant | Notes |
| :--- | :--- | :--- |
| Index | Collection | One-to-one mapping |
| Document | Point | Each document becomes a point |
| `knn_vector` field | Vector | Mapped automatically |
| Document fields | Payload | Non-vector fields become payload |
| `cosinesimi... | [
0.06355706602334976,
-0.09026334434747696,
-0.04346757382154465,
-0.05151287838816643,
0.09941618889570236,
-0.014579848386347294,
0.053709521889686584,
0.05278076231479645,
0.06253749132156372,
-0.045206889510154724,
0.041437581181526184,
-0.0072824591770768166,
0.04167250916361809,
-0.03... |
c1c4297b-5a5f-598a-a257-7a9f2bb7fa9e | /course/multi-vector-search/module-1/use-cases-multi-vector/ | Use Cases for Multi-Vector Search | A Concrete Demonstration > Multi-Vector with ColBERT: Token-Level Verification | course | true | Use Cases for Multi-Vector Search > A Concrete Demonstration > Multi-Vector with ColBERT: Token-Level Verification
Now let's use ColBERT's multi-vector approach:
```python
from fastembed import LateInteractionTextEmbedding
# Load the colbert-ir/colbertv2.0 model
colbert_model = LateInteractionTextEmbedding("colbert-... | [
0.027063462883234024,
-0.0486755408346653,
-0.04056617245078087,
-0.06382323056459427,
0.051082268357276917,
-0.01229819469153881,
0.05307615548372269,
0.0149478018283844,
0.07781721651554108,
-0.025644546374678612,
0.015060575678944588,
0.023128537461161613,
0.057177573442459106,
-0.02883... |
c1d9c5d5-2eb8-5c4d-a1f5-78c333213230 | /documentation/manage-data/quantization/ | Quantization | TurboQuant Quantization > Encoding Options | documentation | false | Quantization > TurboQuant Quantization > Encoding Options
TurboQuant supports five bit depths:
| Encoding | Bit Depth | Compression |
|----------|-----------|-------------|
| `bits8` | 8 bits | 4× |
| `bits4` (default) | 4 bits | 8× |
| `bits2` | 2 bits | 16× |
| `bits1_5` | 1.5 bits... | [
0.04097287356853485,
-0.03625864535570145,
-0.04353707656264305,
-0.06578116863965988,
0.015474196523427963,
0.0007460479391738772,
0.05127321556210518,
0.06608661264181137,
0.08796688169240952,
-0.012359006330370903,
0.051918018609285355,
0.022925755009055138,
0.025166425853967667,
-0.037... |
c1e448fb-fb02-5b59-b594-f0cc9cded7d7 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vectors > Vectors are Fixed-Size | article | false | Why Vector Search Needs a Dedicated Database > Vectors > Vectors are Fixed-Size
Embedding models are designed to produce vectors of a fixed size. We have to use it to our advantage.
For fast search, vectors need to be instantly accessible. Whether in [**RAM or disk**](/documentation/manage-data/storage/), vectors sho... | [
0.01938393898308277,
-0.04417429491877556,
-0.05132293701171875,
-0.03617662936449051,
0.03126051276922226,
-0.0287427119910717,
0.021733954548835754,
-0.011631680652499199,
0.08105414360761642,
-0.015577880665659904,
0.01849268563091755,
0.03519420698285103,
0.06491310894489288,
-0.032876... |
c1ecf205-7f81-56fa-bb0b-7ca23a463a59 | /articles/what-is-a-vector-database/ | What is a Vector Database? | Time to Experiment | article | false | What is a Vector Database? > Time to Experiment
As we've seen in this article, a vector database is definitely not **just** a database as we traditionally know it. It opens up a world of possibilities, from advanced similarity search to hybrid search that allows content retrieval with both context and precision.
But ... | [
0.005972584243863821,
-0.06266958266496658,
-0.058866918087005615,
-0.04920242354273796,
0.04529167711734772,
-0.018892521038651466,
0.048547495156526566,
0.013737155124545097,
0.05019701272249222,
-0.02002161182463169,
0.04314078390598297,
0.0259716734290123,
0.06433895230293274,
-0.04059... |
c1f180ce-0dc7-565f-acc2-39033f8a4582 | /documentation/production-operations/memory-tiers/ | Memory Tiers in Qdrant: What to Use and When | Pin Quantized Vectors for Predictability | documentation | false | Memory Tiers in Qdrant: What to Use and When > Pin Quantized Vectors for Predictability
Pin the compressed copy once a collection is large enough that RAM becomes the binding constraint, not just raw speed. That fixed reservation is what keeps pinning safe as a collection keeps growing, well past the point where the o... | [
0.023535888642072678,
-0.05212162435054779,
-0.04496859014034271,
-0.05419475957751274,
0.05297587439417839,
-0.052093952894210815,
0.04151790216565132,
0.01648762822151184,
0.12240517139434814,
-0.018394583836197853,
0.005841714795678854,
0.006366027053445578,
0.048879895359277725,
-0.018... |
c1f20644-f1e6-5aed-968e-d57e7147bcc8 | /documentation/embeddings/superlinked/ | Superlinked | ColBERT Multivectors | documentation | true | Superlinked > ColBERT Multivectors
Late-interaction models such as `jinaai/jina-colbert-v2` return one vector per token. Qdrant stores them as a [multivector](/documentation/manage-data/vectors/#multivectors) and scores them with MaxSim on the server, so you don't compute late-interaction scores in your application. S... | [
0.029903452843427658,
0.014307350851595402,
-0.017713408917188644,
-0.04462889954447746,
0.047410305589437485,
-0.025502566248178482,
0.08050685375928879,
0.04293861612677574,
0.07021181285381317,
-0.02105339989066124,
0.05224144831299782,
0.0020347675308585167,
0.05851924046874046,
-0.004... |
c1ffe7de-a919-5f13-ae3b-6487003ea19f | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-3/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives | Retrieval Metrics | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives > Retrieval Metrics
We evaluate with standard information retrieval metrics on 2,000 test queries against 10,000 products:
- **nDCG@k**: Ranking quality with position bias; top results matter more
- **MRR@k**: How high the fir... | [
0.0475221648812294,
-0.05143270641565323,
-0.05199052393436432,
-0.034513503313064575,
0.046366747468709946,
-0.03937798738479614,
0.0690263882279396,
0.006479471456259489,
0.1144370511174202,
-0.026725424453616142,
0.0018018665723502636,
0.012231444008648396,
0.08165483176708221,
-0.03133... |
c1fffc15-7b5e-547b-bd4b-04643852e97b | /articles/what-is-vector-quantization/ | What is Vector Quantization? | 2. What is Binary Quantization? | article | true | What is Vector Quantization? > 2. What is Binary Quantization?

[Binary Quantization](https://qdrant.tech/documentation/manage-data/quantization/#binary-quantization) is an excellent option if you're looki... | [
0.04123717173933983,
-0.03257964551448822,
-0.03924795612692833,
-0.04666266590356827,
0.05928131192922592,
-0.02041015774011612,
0.028441287577152252,
0.03156449273228645,
0.11477548629045486,
-0.03621936962008476,
0.04391733556985855,
-0.013814106583595276,
0.04936917871236801,
-0.015222... |
c200b0f5-e900-55ce-a9e4-84ed773d882e | /articles/distance-based-exploration/ | Data Exploration with Qdrant's Distance Matrix API | Hidden Structure | article | false | Data Exploration with Qdrant's Distance Matrix API > Hidden Structure
When working with large collections of documents, images, or other arrays of unstructured data, it often becomes useful to understand the big picture.
Examining data points individually is not always the best way to grasp the structure of the data.
... | [
0.06854893267154694,
-0.0376768596470356,
-0.07558237761259079,
-0.003077794797718525,
0.06710409373044968,
-0.03520356863737106,
0.09578581154346466,
0.07249875366687775,
0.07299166172742844,
-0.0409298874437809,
0.05833599716424942,
0.014871221967041492,
0.03959758207201958,
0.0003221378... |
c20b902b-d35b-5c6f-9343-667046e43818 | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | documentation | false | Keeping Postgres and Qdrant in Sync
If you've migrated your vectors to Qdrant but still use Postgres as your source of truth, the next challenge is keeping both systems in sync as data changes.
This guide covers three progressively robust sync architectures — from simple application-level dual-writes to production-gr... | [
0.02839559130370617,
-0.059662509709596634,
-0.024127960205078125,
-0.036132749170064926,
-0.002295652637258172,
-0.027125710621476173,
0.0733455941081047,
0.013669291511178017,
0.05419837683439255,
-0.014125928282737732,
0.013751368038356304,
0.03883343189954758,
0.04914015904068947,
-0.0... | |
c2101a18-dcd8-52e4-ac3c-6a3cca9853bc | /documentation/agentic-tools/ | Agentic Tools | documentation | false | Agentic Tools
Qdrant provides tools and resources that help AI agents work with Qdrant more effectively.
Use them to give your agent task-specific guidance, troubleshoot existing deployments, design and evaluate search systems, and apply Qdrant best practices to your specific use case.
## Start Building
If you're ne... | [
0.03337705507874489,
-0.04727873578667641,
-0.06761487573385239,
-0.023803172633051872,
0.06326878815889359,
-0.04769415408372879,
0.06262814998626709,
0.0025890108663588762,
0.08876439929008484,
-0.042470142245292664,
0.03714538738131523,
0.0023458662908524275,
0.033827733248472214,
-0.03... | |
c234983e-6ca2-5806-b483-039684018198 | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | Which Framework is Best? > AutoGen | article | false | What is Agentic RAG? Building Agents with Qdrant > Which Framework is Best? > AutoGen
It's worth noting that AutoGen is currently undergoing significant updates, with version 0.4.x in development
introducing substantial API changes compared to the stable 0.2.x release. While the framework currently has limited
built-i... | [
-0.03871278837323189,
-0.041911423206329346,
-0.05028099939227104,
-0.05440197512507439,
0.08294101059436798,
-0.06339412927627563,
0.03848732262849808,
0.015252931974828243,
0.057591017335653305,
-0.07865378260612488,
0.06456949561834335,
0.04912194609642029,
0.07118880748748779,
-0.04303... |
c2395ff3-4697-5461-b1fa-a66b4c72c096 | /documentation/production-operations/managed-cloud-prometheus/ | Managed Cloud Prometheus Monitoring | Step 3: Access Grafana | documentation | true | Managed Cloud Prometheus Monitoring > Step 3: Access Grafana
Once Prometheus is configured to scrape metrics from Qdrant, you can access Grafana to visualize the metrics.
Get the Grafana 'admin' user password by running:
```bash
kubectl --namespace monitoring get secrets prometheus-grafana -o jsonpath="{.data.admin-... | [
0.023675842210650444,
-0.009730435907840729,
-0.025268474593758583,
0.009346404112875462,
0.05275561660528183,
-0.0408073365688324,
0.05843566730618477,
0.0725664272904396,
0.01894128881394863,
-0.009118312038481236,
0.049539949744939804,
-0.006074718199670315,
0.08635615557432175,
-0.0225... |
c239ee1e-54de-56aa-b9b0-5682868117d0 | /documentation/overview/vector-search/ | Understanding Vector Search in Qdrant | The Tower of Babel | documentation | false | Understanding Vector Search in Qdrant > The Tower of Babel
Every once in a while, when we discover new problems with inverted indexes, we come up with a new heuristic to tackle it, at least to some extent. Once we realized that people might describe the same concept with different words, we started building lists of s... | [
0.045732464641332626,
-0.04017634317278862,
-0.0592268742620945,
-0.01718263514339924,
0.058653756976127625,
-0.06370629370212555,
0.07897993922233582,
0.00945140141993761,
0.08281736820936203,
-0.00093755655689165,
0.035904064774513245,
0.04631025344133377,
0.062079593539237976,
-0.054945... |
c244f1b9-c1ba-5e31-98a2-dc897cb08398 | /documentation/tutorials-build-essentials/rag-deepseek/ | 5-Minute RAG with DeepSeek | Prerequisites | documentation | false | 5-Minute RAG with DeepSeek > Prerequisites
Ensure you have the following:
- Python environment (3.10+)
- Access to [Qdrant Cloud](https://qdrant.tech)
- A DeepSeek API key from [DeepSeek Platform](https://platform.deepseek.com/api_keys)
The Qdrant retrieval steps were checked with Qdrant 1.19.1 and `qdrant-client` 1.... | [
0.05100870132446289,
-0.05631967633962631,
0.0028241975232958794,
-0.01590062491595745,
0.05111346393823624,
-0.057500433176755905,
0.036347221583127975,
0.047147635370492935,
0.06675098091363907,
-0.06187788024544716,
0.021349547430872917,
0.028962014243006706,
0.06070892512798309,
-0.053... |
c2542fe5-0e66-53bb-b8d0-0e15749d1392 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-3/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives | ANCE-inspired Hard Negative Mining > Mining Implementation | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 3: Evaluation and Hard Negatives > ANCE-inspired Hard Negative Mining > Mining Implementation
Run this block from the root of the research repository. `queries_with_positives` is a list of `{"query", "positive_ids", "positive_text"}` dicts.
```python
from src... | [
0.05345381051301956,
-0.05029948428273201,
-0.03595573827624321,
-0.03578997403383255,
0.043140046298503876,
-0.03824353963136673,
0.08088689297437668,
0.02901366539299488,
0.05859329551458359,
-0.048094864934682846,
0.026424234732985497,
-0.0035065372940152884,
0.02278202399611473,
-0.027... |
c272b5f9-fee6-5310-a9a7-9b99ebd07e5f | /documentation/manage-data/multitenancy/ | Multitenancy | Tiered Multitenancy > Promote Tenant to Dedicated Shard | documentation | true | Multitenancy > Tiered Multitenancy > Promote Tenant to Dedicated Shard
When a tenant grows large enough, you can promote it to its own dedicated shard.
To do this, first create a new shard for the tenant:
```python
client.create_shard_key(
"{collection_name}",
shard_key="user_1",
shards_number=1,
repl... | [
-0.017606763169169426,
0.0014522145502269268,
-0.023516450077295303,
-0.023772431537508965,
0.05610164999961853,
-0.041563812643289566,
0.04018420726060867,
0.04129998758435249,
0.03353917971253395,
-0.030487308278679848,
0.0435846745967865,
0.05231452360749245,
0.03819764405488968,
-0.032... |
c29a6497-9141-549e-a527-5f2ac6c515c1 | /documentation/manage-data/multitenancy/ | Multitenancy | Partition by Payload > Limitations | documentation | false | Multitenancy > Partition by Payload > Limitations
- Global requests (without the `group_id` filter) are slower, since they require scanning all groups to identify the nearest neighbors.
- When using [BM25 full-text search](/documentation/search/text-search/full-text-search/), or [sparse vector search](/documentation/s... | [
0.017464127391576767,
-0.013286774978041649,
-0.052261464297771454,
-0.026231886819005013,
0.04963843524456024,
-0.011092056520283222,
0.06287503242492676,
0.029375774785876274,
0.10686496645212173,
-0.005818142089992762,
0.044372815638780594,
0.04092453047633171,
0.0285140760242939,
0.001... |
c2dfa90e-ff03-58bb-bb44-4a94df4e3c6e | /documentation/tutorials-operations/data-streaming-kafka-qdrant/ | Kafka Streaming into Qdrant | documentation | false | Kafka Streaming into Qdrant
**Author:** [M K Pavan Kumar](https://www.linkedin.com/in/kameshwara-pavan-kumar-mantha-91678b21/) , research scholar at [IIITDM, Kurnool](https://iiitk.ac.in). Specialist in hallucination mitigation techniques and RAG methodologies.
• [GitHub](https://github.com/pavanjava) • [Medium](http... | [
0.048087578266859055,
-0.009487653151154518,
-0.08187199383974075,
-0.028316689655184746,
0.04008820652961731,
-0.008061799220740795,
0.03678371012210846,
0.0875866711139679,
0.06565026193857193,
-0.001772221177816391,
0.025726979598402977,
0.0032154100481420755,
0.08000798523426056,
-0.05... | |
c2f37250-fc80-55d6-901a-62df48153730 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Which Model to Choose | course | false | Demo: Keyword Search with Sparse Vectors > Which Model to Choose
| | **BM25** | **miniCOIL** | **SPLADE** |
|---|---|---|---|
| **When to use** | Strong baseline; fast, lightweight, no setup required | BM25 upgrade with contextual ranking; still lightweight exact keyword matches | When synonym-like recall matters and... | [
0.030272966250777245,
-0.050499383360147476,
-0.036548491567373276,
-0.042760107666254044,
0.055484283715486526,
-0.05228206515312195,
0.07663516700267792,
0.010012625716626644,
0.0422162301838398,
-0.02966272458434105,
0.030989201739430428,
0.023996951058506966,
0.05595332384109497,
-0.01... |
c3035c4c-b3bd-5eef-984b-1af35a47cd32 | /documentation/tutorials-search-engineering/branch-aware-search/ | Branch-Aware Search | Step 3: Delete a File | documentation | true | Branch-Aware Search > Step 3: Delete a File
A delete is a commit too, so it carries a `seq` like any other.
```text
root ●───────●───────● seq 2: delete notes.md
seq 0 seq 1 seq 2
```
It writes the same mark as an overwrite, with no replacement point behind it:
```python
def delete(file_name, branch, ... | [
0.019359856843948364,
-0.0527847483754158,
-0.04616142064332962,
-0.02199355885386467,
0.004582265391945839,
0.00474735489115119,
0.019533390179276466,
0.03931736201047897,
0.0660267174243927,
-0.03594271093606949,
0.038314059376716614,
0.014279384166002274,
0.017275307327508926,
-0.022115... |
c30ffae7-a6f6-59a1-918c-f40b19ff7ca2 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Text to Tokens | course | false | Demo: Keyword Search with Sparse Vectors > Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Text to Tokens
Each document is first tokenized and the resulting tokens are mapped to their corresponding indices in the model’s vocabulary.
These indices are then used in the final sparse representation... | [
0.08949021995067596,
-0.0651337057352066,
-0.01010398380458355,
-0.07451269030570984,
0.09550584852695465,
-0.041061025112867355,
0.04956088960170746,
0.026905586943030357,
0.03572656586766243,
-0.02561248652637005,
0.03699975088238716,
0.005661611445248127,
0.029842935502529144,
-0.020064... |
c334d29f-c37c-5c19-8300-7bed89f61638 | /documentation/tutorials-basics/reranking-hybrid-search/ | Hybrid Search with Reranking | Implementation > Models | documentation | true | Hybrid Search with Reranking > Implementation > Models
Next, define the two embedding models. You'll use the 384-dimensional [`sentence-transformers/all-MiniLM-L6-v2`](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) model for dense embeddings and the 96-dimensional [`answerdotai/answerai-colbert-small-v... | [
0.03554077818989754,
-0.0007041569915600121,
-0.038490843027830124,
-0.04653909057378769,
0.052115920931100845,
-0.03754739463329315,
0.062310561537742615,
0.05995400995016098,
0.06575454026460648,
0.008573749102652073,
0.04293695464730263,
0.01277177594602108,
0.050756972283124924,
-0.024... |
c34371c5-62ee-55cc-8f13-f9039e8b6162 | /documentation/tutorials-operations/secure-qdrant/ | Secure a Self-Hosted Qdrant Instance | Prerequisites | documentation | false | Secure a Self-Hosted Qdrant Instance > Prerequisites
- [Docker](https://docs.docker.com/get-docker/) and [Docker Compose](https://docs.docker.com/compose/install/) installed
- `curl` available in your terminal
- [mkcert](https://github.com/FiloSottile/mkcert#readme) for generating a local self-signed certificate ([ins... | [
0.02302785962820053,
-0.05019974708557129,
-0.04194871708750725,
-0.025485441088676453,
0.017724815756082535,
-0.0635991171002388,
0.05330464243888855,
0.03772396966814995,
0.08082220703363419,
-0.027314046397805214,
0.03058796003460884,
0.02389216423034668,
0.05340096354484558,
-0.0710467... |
c35ec4fb-0be3-54b8-8296-2a77030e7865 | /documentation/edge/edge-bm25/ | BM25 | Query | documentation | true | BM25 > Query
Use `embed_query` to generate a sparse vector for the query text, then query the shard:
```python
from qdrant_edge import Query, QueryRequest
query_vector = bm25.embed_query("clever fox")
results = shard.query(QueryRequest(
query=Query.Nearest(query_vector, using="text"),
limit=3,
with_payl... | [
0.04357771947979927,
-0.0581444650888443,
-0.020974621176719666,
-0.040886588394641876,
0.04539095237851143,
-0.03954358771443367,
0.0824676975607872,
0.04246588796377182,
0.020773887634277344,
0.014111146330833435,
0.030202340334653854,
0.01485472172498703,
0.013588368892669678,
-0.035713... |
c364b728-84fe-56a1-9ca1-bb28fd2ce63d | /documentation/manage-data/multitenancy/ | Multitenancy | Partition by Payload > Calibrate Performance | documentation | true | Multitenancy > Partition by Payload > Calibrate Performance
Indexing speed can become a bottleneck when many tenants share a collection, since their vectors are all indexed together. To avoid this bottleneck, consider disabling the global vector index for the collection and building it only for individual groups inste... | [
0.040807388722896576,
-0.016676301136612892,
-0.05059284716844559,
-0.003145654918625951,
0.050322648137807846,
-0.038644030690193176,
0.043581731617450714,
0.018866490572690964,
0.07475423812866211,
-0.018275342881679535,
0.014399898238480091,
0.025899311527609825,
0.044337041676044464,
-... |
c368c73e-20b0-52f3-a29e-d2f3f734a28a | /documentation/search/filtering/ | Filtering | Filtering Conditions > Text Match > Full-Text Any | documentation | true | Filtering > Filtering Conditions > Text Match > Full-Text Any
*Available as of v1.16.0*
The `text_any` full-text match condition is similar to the `text` condition, but with a key difference: while `text` only matches text fields that contain *all* the query terms, `text_any` matches fields that contain *any* of the ... | [
0.024993086233735085,
-0.05259604752063751,
-0.06251378357410431,
-0.05886443331837654,
0.03719290345907211,
0.002586242975667119,
0.037766266614198685,
0.01431064959615469,
0.06325267255306244,
-0.02176055870950222,
0.04908411577343941,
0.04035365954041481,
0.04750077798962593,
-0.0237223... |
c3769269-8dc8-5a4a-972d-9b0c8e08c537 | /documentation/edge/edge-api/configuration/ | Configuration | EdgeConfig | documentation | false | Configuration > EdgeConfig
A new shard must define at least one of `vectors` or `sparse_vectors`; both are validated against the existing segments on `load`. Python raises `ValueError` if both are empty, so changing only a tunable parameter still requires redeclaring the vectors. Rust accepts a tunables-only configura... | [
0.014918162487447262,
-0.03914128616452217,
-0.03981534391641617,
-0.04842269420623779,
0.020482704043388367,
-0.05399943143129349,
0.04643206670880318,
0.036253925412893295,
0.03200526162981987,
-0.013669466599822044,
0.038015834987163544,
0.03138716518878937,
0.047080256044864655,
-0.018... |
c37b48cc-025e-5293-ac13-a9da41de7ea7 | /course/essentials/day-4/large-scale-ingestion/ | Large-Scale Data Ingestion | course | false | Large-Scale Data Ingestion
Day 4
In vector search applications inserting a few thousand data points is straightforward but the dynamics change completely when dealing with millions or billions of records. Tiny inefficiencies in the ingestion process compound into significant time losses, increased memory pressure, an... | [
0.034753601998090744,
-0.04783530905842781,
-0.03392273932695389,
-0.019749179482460022,
0.06658173352479935,
-0.03377465531229973,
0.05675330013036728,
0.046837180852890015,
0.0826818197965622,
-0.018798798322677612,
0.0016965449322015047,
0.015555042773485184,
0.03029046766459942,
-0.024... | |
c384d2d1-8c82-52af-bf4f-63e137a5446c | /documentation/frameworks/deepeval/ | DeepEval | How it works | documentation | false | DeepEval > How it works
A test case is a blueprint provided by DeepEval to unit test LLM outputs. There are two types of test cases in DeepEval:
`LLMTestCase`: Used to evaluate a single input-output pair, such as RAG responses or agent actions.
`ConversationalTestCase`: A sequence of `LLMTestCase` turns representing... | [
0.02683470956981182,
-0.04324212297797203,
-0.06599597632884979,
-0.07194353640079498,
0.005361569579690695,
-0.029268532991409302,
0.0835990160703659,
0.05554485321044922,
0.06287651509046555,
-0.029445689171552658,
0.013675163500010967,
0.013875104486942291,
0.000019619781596702524,
0.00... |
c3915529-6e22-5f9e-a29a-8575c4d43294 | /articles/universal-io/ | Universal I/O in Qdrant | A Bridge to Async-Land | article | true | Universal I/O in Qdrant > A Bridge to Async-Land
None of the code described so far uses async Rust, but network reads need it, since a single round trip takes tens of milliseconds and running requests one after another would be far too slow. They have to run concurrently without too much threading overhead, which rais... | [
0.02612307108938694,
-0.02797412872314453,
-0.047760624438524246,
-0.019788850098848343,
0.04835858941078186,
-0.020380359143018723,
0.0523361973464489,
0.002910943701863289,
0.056761063635349274,
0.016795964911580086,
0.011425744742155075,
-0.015492399223148823,
0.07294045388698578,
0.011... |
c3c4ab9f-dc72-5382-be09-531c50c5a15b | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | RRF and DBSF Use Different Signals | documentation | false | How to Tune Hybrid Search in Qdrant > RRF and DBSF Use Different Signals
[Reciprocal Rank Fusion](/documentation/search/hybrid-queries/#reciprocal-rank-fusion-rrf) (RRF) uses only a candidate's position in each prefetch. A document at rank 1 scores the same whether it beat rank 2 by a wide margin or a narrow one. [Dis... | [
0.014098156243562698,
-0.030620146542787552,
-0.04264844208955765,
-0.07086453586816788,
0.04332493618130684,
-0.0500544011592865,
0.05365299433469772,
0.03887736052274704,
0.04534761235117912,
-0.023786485195159912,
0.015327317640185356,
-0.019393274560570717,
0.053361594676971436,
0.0193... |
c40047b0-7fce-5635-8913-5da1522f7673 | /documentation/edge/edge-quickstart/ | Quickstart | Tune the Search Thread Pool | documentation | true | Quickstart > Tune the Search Thread Pool
Each Edge Shard owns a thread pool that runs per-segment reads such as `query`, `scroll`, `count`, and `facet` in parallel. The pool is built once when the shard opens and kept for its lifetime.
By default the pool is deliberately larger than the CPU count: four threads per CP... | [
0.019341297447681427,
-0.06709820032119751,
-0.049128782004117966,
0.003540600882843137,
0.055615734308958054,
-0.05196520686149597,
0.07644686847925186,
0.043783038854599,
0.07053913921117783,
-0.03557993099093437,
0.05470805987715721,
-0.0020560582634061575,
0.0217491015791893,
-0.028543... |
c404ee4d-5a6d-5ef9-b0c7-85a6c548f68d | /documentation/ops-optimization/optimize/ | Optimize Performance | Summary | documentation | false | Optimize Performance > Summary
By adjusting configurations like vector storage, quantization, and search parameters, you can optimize Qdrant for different use cases:
- **Low Memory + High Speed:** Use vector quantization.
- **High Precision + Low Memory:** Store vectors and HNSW index in the `cold` memory tier.
- **Hi... | [
0.028485922142863274,
-0.04797910153865814,
-0.03475112095475197,
-0.026412619277834892,
0.05870191380381584,
-0.031227784231305122,
0.06713300198316574,
-0.003145781345665455,
0.0868886187672615,
-0.011660062707960606,
-0.0026602030266076326,
-0.005230869632214308,
0.05226423591375351,
-0... |
c416b502-7134-507d-b159-80849e1a9394 | /documentation/edge/edge-api/updating-data/ | Updating Data | Update Operations | documentation | false | Updating Data > Update Operations
In Python, `UpdateOperation` is a class with static constructors, one per operation. Each returns an `UpdateOperation` to pass to `update`. | [
-0.024700211361050606,
-0.028415808454155922,
-0.026978718116879463,
-0.04774939641356468,
0.07607991248369217,
-0.0038598361425101757,
0.04784078150987625,
0.012288596481084824,
0.08570713549852371,
-0.017956731840968132,
0.013790198601782322,
0.0917312502861023,
0.03731493279337883,
-0.0... |
c41991a7-8340-5789-83f2-0cb8d96dbb16 | /course/essentials/day-3/ | Day 3: Hybrid Search | course | false | Day 3: Hybrid Search
Day 3
Combine dense and sparse signal for precision and recall.
---
## Today’s path
1. Sparse Vectors and Inverted Indexes
2. Keyword‑based search demo
3. Hybrid Search with Score Fusion
4. Demo: Implementing a Hybrid Search System
5. Project: Building a Hybrid Search Engine
You’ll build a hy... | [
0.044199541211128235,
-0.014955246821045876,
-0.05053997039794922,
-0.05030153691768646,
0.05696187540888786,
-0.040375180542469025,
0.061321184039115906,
0.029339471831917763,
0.08846025913953781,
-0.04851282760500908,
0.035355739295482635,
0.059497371315956116,
0.05300970748066902,
-0.01... | |
c43508e7-8e49-575f-acf5-e16dd9943187 | /documentation/edge/edge-api/shard-lifecycle/ | Shard Lifecycle | Flush Pending Changes | documentation | true | Shard Lifecycle > Flush Pending Changes
Persists the write-ahead log and all segments to disk.
```python
def flush(self) -> None
```
**Returns** nothing in Python. In Rust, returns `Ok(())` on success, or an error if the WAL or a segment could not be flushed.
`flush` blocks until the WAL and segment locks are free.... | [
0.028053393587470055,
-0.013558399863541126,
-0.02892358787357807,
0.0015451349318027496,
0.06456531584262848,
-0.06194525584578514,
0.03275660052895546,
-0.027599427849054337,
0.04692580923438072,
0.0003158251929562539,
0.02349628321826458,
0.010914456099271774,
0.04263315722346306,
-0.02... |
c43d703e-e882-5873-8c84-4625840fc4b0 | /documentation/edge/edge-quickstart/ | Quickstart | Initialize the Edge Shard | documentation | true | Quickstart > Initialize the Edge Shard
Now you can create a new `EdgeShard` using `EdgeShard.create` (Python) or `EdgeShard::new` (Rust), passing the storage directory and configuration:
```python
from qdrant_edge import EdgeShard
edge_shard = EdgeShard.create(SHARD_DIRECTORY, config)
```
Note that `create` and `ne... | [
0.019363781437277794,
-0.02896890416741371,
-0.02494085766375065,
-0.042577531188726425,
0.04993623495101929,
-0.04696023091673851,
0.058869536966085434,
0.021312328055500984,
0.06508778780698776,
-0.04844903573393822,
0.030825849622488022,
0.026314588263630867,
0.05277971550822258,
-0.005... |
c449baf7-e097-5f77-897f-25b57ced9a45 | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | What Agents Need from the Retrieval Layer | article | false | What is Agentic RAG? Building Agents with Qdrant > What Agents Need from the Retrieval Layer
An agent calls retrieval repeatedly, with state that changes between calls. That puts a few requirements on the retrieval layer.
- **Latency that does not compound.** An agent can run several searches in sequence to answer on... | [
0.005372820887714624,
-0.019132735207676888,
-0.07331685721874237,
-0.03434854373335838,
0.07225920259952545,
-0.05598953366279602,
0.06238701194524765,
0.019093865528702736,
0.09885786473751068,
-0.031188523396849632,
0.02546979859471321,
0.008220943622291088,
0.07258418947458267,
-0.0256... |
c4639719-ec89-5eab-88be-9c0a7eea1495 | /documentation/frameworks/deepeval/ | DeepEval | Metrics Overview | documentation | false | DeepEval > Metrics Overview
DeepEval offers a suite of metrics to evaluate various aspects of LLM outputs, including:
- **Answer Relevancy**: Measures how relevant the LLM's output is to the given input query.
- **Faithfulness**: Assesses whether the LLM's response is grounded in the provided context, ensuring factua... | [
0.025828413665294647,
-0.013824548572301865,
-0.040026530623435974,
-0.06576744467020035,
0.025402192026376724,
0.0062605454586446285,
0.06667406111955643,
0.048707906156778336,
0.0691087543964386,
-0.057787202298641205,
0.028268294408917427,
-0.001793424948118627,
0.08841633796691895,
0.0... |
c4654cd3-57ac-5398-9c74-c80848a683a8 | /documentation/tutorials-operations/blue-green-deployment/ | Blue-Green Cluster Deployment | Step 3: Test and Validate | documentation | false | Blue-Green Cluster Deployment > Step 3: Test and Validate
Before switching traffic, validate the green cluster thoroughly. At a minimum, check:
- [**Point counts**](/documentation/manage-data/points/#counting-points)**.** Verify that each collection on the green cluster has the expected number of points. If the goal ... | [
0.044416528195142746,
-0.06228499114513397,
-0.034794025123119354,
-0.042883582413196564,
0.0385126955807209,
-0.025251111015677452,
0.04362865164875984,
0.030809296295046806,
0.0371696911752224,
-0.022715019062161446,
0.02801729366183281,
0.04391695186495781,
0.011299160309135914,
-0.0287... |
c47e6b38-fa30-5967-910b-657a8f333cac | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Search > What are the three approaches to filtering in Qdrant, and when should I use each? | documentation | false | Qdrant Fundamentals > Search > What are the three approaches to filtering in Qdrant, and when should I use each?
There are three strategies:
1. **Payload index only** — purely logical separation via filtering. Works for any cardinality.
2. **Payload index with `is_tenant=true`** — logical separation plus physical c... | [
0.03407919406890869,
-0.026948468759655952,
-0.050595901906490326,
-0.025074724107980728,
0.05145503580570221,
-0.029204150661826134,
0.05359077453613281,
0.023432206362485886,
0.07044462859630585,
-0.018630294129252434,
0.016487082466483116,
0.0013974696630612016,
0.04296408221125603,
-0.... |
c483223d-4ad5-5e1c-b2ea-6c1d125bf91b | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > ReadCluster | documentation | false | API Reference > qdrant.io/v1 > Resource Types > ReadCluster
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `id` _string_ | Id specifies the unique identifier of the read cluster | | | | [
0.056325431913137436,
-0.035153523087501526,
-0.04521603509783745,
-0.04446009173989296,
0.08002113550901413,
-0.030859094113111496,
0.030916115269064903,
0.0858502984046936,
0.03477584943175316,
-0.0319889634847641,
0.042059801518917084,
-0.0009095978457480669,
0.06497108936309814,
0.0166... |
c4908152-6a11-5af6-871d-161563b27e7f | /course/beginners/module-4/what-changes-as-the-collection-grows/ | What Changes as the Collection Grows | course | true | What Changes as the Collection Grows
Module 4
This three-article collection needs no tuning. At millions of points, both the indexing and storage layers need attention.
### Index Time Against Search Quality
Module 2 introduced `m` and `ef_construct`, which control how much work goes into building the HNSW graph. Hi... | [
0.023893769830465317,
-0.038291286677122116,
-0.05086030438542366,
-0.02456671930849552,
0.05723884329199791,
-0.057576436549425125,
0.06227191165089607,
0.06029185280203819,
0.07042884081602097,
-0.03775264695286751,
0.008509513922035694,
0.048287563025951385,
0.03020651452243328,
-0.0226... | |
c498115f-fc78-56ff-9d8a-a7f0a1b61815 | /course/essentials/day-3/pitstop-project/ | Project: Building a Hybrid Search Engine | Share Your Discovery | course | true | Project: Building a Hybrid Search Engine > Share Your Discovery
### Step 1: Reflect on Your Findings
1. When did hybrid search beat dense-only or sparse-only (give concrete query types)?
2. How did RRF change the ranking vs. the individual methods?
3. How did latency compare across dense, sparse, and hybrid (avg + P9... | [
0.050664979964494705,
-0.05324319750070572,
-0.05296797677874565,
-0.038302402943372726,
0.048832740634679794,
-0.03869372978806496,
0.034134767949581146,
0.04193159565329552,
0.07043818384408951,
-0.052785035222768784,
0.06323955953121185,
0.0010945061221718788,
0.06634903699159622,
0.000... |
c49bc767-8b40-56a8-a91a-b949704fad79 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-3/ | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment | Baseline Governance | documentation | false | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment > Baseline Governance
 | Write to both in request handler | Prototypes, < 10K records | None (synchronous) |
| [Tier 2: Transactional Outbox](#tier-2-tr... | [
-0.009521198458969593,
-0.022222623229026794,
-0.030941618606448174,
-0.027562662959098816,
0.022234739735722542,
-0.0642758384346962,
0.04673387482762337,
0.03364751860499382,
0.08263792097568512,
-0.036763228476047516,
0.03197066858410835,
0.0448685958981514,
0.0401877798140049,
-0.03632... |
c4a8a64b-1dbd-52e5-89d0-127437d529c2 | /course/multi-vector-search/module-1/late-interaction-basics/ | Late Interaction Basics | Understanding the Alternatives > Cross-Encoders (Early Interaction) | course | true | Late Interaction Basics > Understanding the Alternatives > Cross-Encoders (Early Interaction)
At the other extreme, cross-encoders process the query and document together through a neural network, producing a relevance score. This is "early interaction" because the query and document interact during the encoding phase... | [
0.009317286312580109,
-0.03675199672579765,
-0.05622735992074013,
-0.06260432302951813,
0.04720093309879303,
-0.023573359474539757,
0.022712375968694687,
0.005161947105079889,
0.0782671719789505,
-0.019954722374677658,
0.00573756592348218,
-0.01372322253882885,
0.05320306867361069,
-0.0205... |
c4afb8cc-6977-5604-9da3-15a356a7ce19 | /documentation/embeddings/cohere/ | Cohere | Embed Images | documentation | true | Cohere > Embed Images
Embed v5 and v4 models place images in the same embedding space as text, so a text query can find an image. Pass images as base64 data URLs in `images`. This example adds an image to the collection from [Embed Documents](#embed-documents):
```python
import base64
with open("diagram.png", "rb") ... | [
0.03246475011110306,
-0.047611407935619354,
-0.044375620782375336,
-0.06443531811237335,
0.0852375328540802,
-0.028635548427700996,
0.046754807233810425,
0.09535287320613861,
0.053928595036268234,
0.0015082148602232337,
0.041595470160245895,
0.005220803897827864,
0.019793512299656868,
-0.0... |
c4ca05ac-348d-513a-8aca-ec6c5cf7858c | /documentation/ops-configuration/running-with-gpu/ | Running with GPU | Standalone GPU Support | documentation | true | Running with GPU > Standalone GPU Support
For standalone usage, you can build Qdrant with GPU support by running the following command:
```bash
cargo build --release --features gpu
```
Ensure your device supports Vulkan API v1.3. This includes compatibility with Apple Silicon, Intel GPUs, and CPU emulators. Note tha... | [
0.023030197247862816,
-0.07857124507427216,
-0.0473066084086895,
-0.010590726509690285,
0.05533834174275398,
-0.029685981571674347,
0.076234370470047,
0.03799206390976906,
0.0534084290266037,
-0.014294901862740517,
0.0601213164627552,
-0.01035523135215044,
0.06326670199632645,
-0.031970210... |
c4eae688-5024-5cbf-8f80-7c05faed01f5 | /documentation/manage-data/indexing/ | Indexing | Sparse Vector Index > IDF Modifier | documentation | true | Indexing > Sparse Vector Index > IDF Modifier
*Available as of v1.10.0*
For many search algorithms, it is important to consider how often an item occurs in a collection.
Intuitively speaking, the less frequently an item appears in a collection, the more important it is in a search.
This is also known as the Inverse ... | [
0.0660955160856247,
-0.03693614527583122,
-0.03283969312906265,
-0.031491804867982864,
0.06659580022096634,
-0.032190121710300446,
0.07752644270658493,
0.03980524092912674,
0.08540140092372894,
-0.026783548295497894,
0.03221967816352844,
0.020118555054068565,
0.02796171046793461,
-0.027278... |
c4f6262a-ec39-5c8b-9955-8cb1f72f16c4 | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Implementation > Ingestion > Extracting Graph Components | documentation | true | GraphRAG with Qdrant and Neo4j > Implementation > Ingestion > Extracting Graph Components
```python
def extract_graph_components(raw_data, node_ids):
prompt = f"Extract nodes and relationships from the following text:\n{raw_data}"
parsed_response = openai_llm_parser(prompt) # Assuming this returns a list of ... | [
0.035410184413194656,
-0.02799041010439396,
-0.05334927514195442,
-0.033209070563316345,
0.07124000042676926,
-0.03375278040766716,
0.04223101958632469,
0.09021735191345215,
0.04805319011211395,
-0.019436711445450783,
0.019995039328932762,
0.02744518592953682,
0.03690531104803085,
-0.01956... |
c52241ec-c5b6-5469-89d9-70990ed4c352 | /documentation/cloud-premium/ | Premium Tier | Uptime SLA | documentation | false | Premium Tier > Uptime SLA
Premium commits to 99.9% quarterly uptime for clusters in a single availability zone and 99.95% for [multi-AZ clusters](#multi-az-clusters). Standard commits to 99.5%. Uptime is measured per cluster over each calendar quarter. If you need a higher commitment than 99.95%, [contact the Qdrant t... | [
0.020197294652462006,
-0.012525909580290318,
-0.04117302596569061,
-0.010550560429692268,
0.05582917481660843,
-0.0710940808057785,
0.05286294221878052,
0.0324983187019825,
0.0911874994635582,
-0.044687967747449875,
0.032820314168930054,
-0.016380896791815758,
0.02964302897453308,
-0.04938... |
c54e03c2-d5d1-5b5b-aab6-7782f2af9fdf | /documentation/ops-optimization/read-write-contention/ | Read-Write Contention | Step 5: Use Delayed Fan-Outs | documentation | true | Read-Write Contention > Step 5: Use Delayed Fan-Outs
*Requires replicas. Available as of v1.17.0.*
This step applies only if your collection has a replication factor greater than one. If you're running without replicas, skip to step 6.
Under write pressure, some replicas may respond slower than others. They may be c... | [
0.022776324301958084,
-0.042576659470796585,
-0.06943391263484955,
-0.03266023099422455,
0.06480720639228821,
-0.040799129754304886,
0.016736600548028946,
0.02939135953783989,
0.08850658684968948,
-0.03463194519281387,
0.025103328749537468,
-0.005341922864317894,
0.07596062123775482,
-0.00... |
c54ece04-df7b-58e6-8ec5-ea6e38849723 | /course/multi-vector-search/module-2/colpali-family/ | ColPali Family Overview | Supported Languages | course | false | ColPali Family Overview > Supported Languages
Original ColPali model primarily focuses on English documents, but several multilingual alternatives have emerged that extend multi-vector capabilities across different languages.
### NVIDIA Multilingual Models
The **[NVIDIA Llama-NeMoRetriever-ColEmbed-3B-v1](https://hu... | [
0.03439604490995407,
-0.028237495571374893,
-0.05402584746479988,
-0.06023816019296646,
0.10466095060110092,
-0.01092692743986845,
0.09060007333755493,
0.04944998025894165,
0.019377224147319794,
-0.04579833522439003,
0.027396246790885925,
-0.0053848219104111195,
0.0347035713493824,
-0.0301... |
c553719b-e098-5273-876e-43399fcf456f | /documentation/embeddings/voyage/ | Voyage AI | documentation | false | Voyage AI
[Voyage AI](https://docs.voyageai.com/docs/embeddings) provides text, code, and multimodal embedding models. There are two ways to use them with Qdrant:
- Call the Voyage AI API from your application and send the vectors to Qdrant. This is what most of this page covers.
- Run the open-weight [`voyage-4-nano... | [
0.05769900605082512,
-0.03445855528116226,
-0.03869260102510452,
-0.04362473636865616,
0.05966250225901604,
-0.039250101894140244,
0.0882943794131279,
0.03518471121788025,
0.009726681746542454,
-0.02351265586912632,
0.028971973806619644,
0.007644975557923317,
0.045683637261390686,
-0.01217... | |
c562741a-a74c-5911-a20f-ebd5f3610b07 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | Confirm the Selected Configuration on Held-Out Queries | documentation | false | How to Tune Hybrid Search in Qdrant > Confirm the Selected Configuration on Held-Out Queries
A configuration can score best on the queries used to select it and still fail on held-out queries. Run both checks from [the pre-tuning article](/documentation/search-tuning/before-tuning-a-qdrant-collection/): a bootstrap in... | [
0.014808449894189835,
-0.026562083512544632,
-0.056570928543806076,
-0.016720201820135117,
0.010863364674150944,
-0.024546682834625244,
0.03891802951693535,
0.06055821478366852,
0.050543464720249176,
-0.01984999142587185,
0.02068040706217289,
-0.009254767559468746,
0.033327311277389526,
-0... |
c56c6e49-e745-5195-8032-0edc3bbf304b | /documentation/send-data/qdrant-airflow-astronomer/ | Querying with Airflow | documentation | false | Querying with Airflow
| Time: 45 min | Level: Intermediate | | |
| ------------ | ------------------- | --- | --- |
In this tutorial, you will use Qdrant as a [provider](https://airflow.apache.org/docs/apache-airflow-providers-qdrant/stable/index.html) in [Apache Airflow](https://airflow.apache.org/), an open... | [
0.013732168823480606,
-0.007048502564430237,
-0.032842595130205154,
-0.02481815405189991,
0.06841163337230682,
-0.032063763588666916,
0.027434300631284714,
0.03180708363652229,
0.021253256127238274,
-0.0075742625631392,
0.020388644188642502,
0.004642556421458721,
0.026600990444421768,
-0.0... | |
c571b87d-d95c-5567-b539-3015d2dd06cd | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum timeout Parameter | documentation | true | Administration > Strict Mode > Maximum timeout Parameter
Long running operations are often symptomatic of a deeper issue.
Setting `max_timeout` caps the maximum value in seconds for the `timeout` parameter in all API operations.
```python
from qdrant_client import QdrantClient, models
client = QdrantClient(url="htt... | [
-0.009155030362308025,
-0.030204683542251587,
-0.000744182791095227,
-0.038687147200107574,
0.04144538193941116,
-0.038219936192035675,
0.021907417103648186,
0.0456516332924366,
0.06929677724838257,
-0.03330274671316147,
0.016511308029294014,
-0.023351047188043594,
0.07690410315990448,
-0.... |
c57fccae-acd3-5794-8def-21935fd68ebe | /course/essentials/day-5/pitstop-project/ | Project: Building a Recommendation System | Next Steps | course | false | Project: Building a Recommendation System > Next Steps
Turn this into a mini‑service: ingest your own items and user signals, write a tiny function that takes profile vectors and returns top‑k via the Universal Query API, then experiment with filters and fusion strategies (try DBSF vs RRF) to see how ranking shifts. | [
0.031666044145822525,
-0.05021935701370239,
-0.015038990415632725,
-0.055788204073905945,
0.03748653084039688,
-0.04237006977200508,
0.057082612067461014,
0.058770276606082916,
0.085528165102005,
0.009568382054567337,
0.029053298756480217,
0.02643975242972374,
0.07665528357028961,
-0.00577... |
c58c2e1e-2c0e-5ae6-85b0-2975215541a8 | /documentation/migration-guidance/pre-migration-baseline/ | Pre-Migration Baseline | What to Capture > 3. Baseline Search Queries | documentation | true | Pre-Migration Baseline > What to Capture > 3. Baseline Search Queries
The most valuable baseline you can capture is search quality. Select 10 to 50 queries that represent your actual search workload:
```py
# Structure for recording baseline queries
baseline_queries = [
{
"query_id": "q001",
"descr... | [
0.004419107921421528,
-0.043190017342567444,
-0.036152396351099014,
-0.039581332355737686,
0.03009060211479664,
-0.024517176672816277,
0.0423724502325058,
0.030491122975945473,
0.08237795531749725,
-0.029849186539649963,
0.03381672129034996,
0.006223735399544239,
0.045508258044719696,
-0.0... |
c58dc5aa-71d7-524e-8b62-6beb00cea051 | /documentation/embeddings/bedrock/ | Amazon Bedrock | Setup | documentation | true | Amazon Bedrock > Setup
Install the AWS SDK and the Qdrant client:
- Python: `pip install boto3 qdrant-client`
- TypeScript: `npm install @aws-sdk/client-bedrock-runtime @qdrant/js-client-rest`
The AWS SDKs read credentials from the default credential chain, such as the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`... | [
0.005196051672101021,
-0.024463709443807602,
-0.0074938274919986725,
-0.011498062871396542,
0.036335933953523636,
-0.06543819606304169,
0.05907046049833298,
0.018032677471637726,
0.017352815717458725,
-0.0052840993739664555,
0.04097989946603775,
0.002617201302200556,
0.05829114466905594,
-... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.