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 |
|---|---|---|---|---|---|---|---|
3c0d7297-5c89-5b2d-989b-e7503297ef72 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-1/ | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS | Local Environment Setup | documentation | true | Video Anomaly Detection Part 1: Architecture, Twelve Labs, and NVIDIA VSS > Local Environment Setup
**1.** Clone the repository into your local environment.
```bash
git clone https://github.com/qdrant/video-anomaly-edge.git
cd video-anomaly-edge
```
**2.** Install dependencies with uv.
```bash
uv sync
```
**3.** A... | [
0.061121825128793716,
-0.07048559188842773,
-0.06433875858783722,
-0.028258634731173515,
0.06029566004872322,
-0.004367089364677668,
0.01646438054740429,
0.01058126799762249,
0.03436503931879997,
-0.026662485674023628,
0.013147917576134205,
0.02368265949189663,
0.06523414701223373,
-0.0311... |
3c2f041c-4d32-52d7-9cad-45b55b4fbaf0 | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | course | false | Combining Vector Search and Filtering
Day 2
We've talked about how Qdrant uses the [HNSW](/documentation/manage-data/indexing/#filterable-hnsw-index) graph to efficiently search dense vectors. But in real-world applications, you'll often want to constrain your search using filters. This creates unique challenges for ... | [
0.06219836696982384,
-0.05291019752621651,
-0.06491857767105103,
-0.025288013741374016,
0.05139736086130142,
-0.026639074087142944,
0.0829966589808464,
0.05497312545776367,
0.050890855491161346,
-0.00524330697953701,
0.026851516216993332,
0.05718938633799553,
0.08121185749769211,
-0.010886... | |
3c50a96f-7192-54eb-8b77-80dcca41e5bc | /documentation/examples/hybrid-search-llamaindex-jinaai/ | Chat With Product PDF Manuals Using Hybrid Search | Configure Credentials | documentation | true | Chat With Product PDF Manuals Using Hybrid Search > Configure Credentials
For local Jupyter, create a `.env` file next to the notebook. Replace the placeholder
values; never commit that file or include its contents in notebook output.
```dotenv
JINAAI_API_KEY=your-jina-api-key
OPENROUTER_API_KEY=your-openrouter-api-k... | [
0.05801282078027725,
-0.03130326420068741,
-0.019834494218230247,
-0.0754818245768547,
0.07437065988779068,
-0.027017537504434586,
0.039343755692243576,
0.08356538414955139,
0.06983351707458496,
-0.01215877290815115,
0.011652383022010326,
0.03909943625330925,
0.09058535844087601,
0.0025922... |
3c777a02-7d38-5af1-b31c-b57792cfb223 | /documentation/examples/rag-chatbot-red-hat-openshift-haystack/ | Private Chatbot for Interactive Learning | Implementation > Indexing pipeline | documentation | true | Private Chatbot for Interactive Learning > Implementation > Indexing pipeline
[Haystack](https://haystack.deepset.ai/) comes packed with a lot of useful components, from data fetching, through
HTML parsing, up to the vector storage. Before we start, there are a few Python packages that we need to install:
```shell
p... | [
0.024962419643998146,
-0.04089689627289772,
-0.02217065915465355,
-0.01243797317147255,
0.06376181542873383,
-0.03362143784761429,
0.03138145059347153,
0.011773298494517803,
0.04204047843813896,
0.004582434892654419,
0.01693684048950672,
0.04049704968929291,
0.04135815054178238,
-0.0614956... |
3c80366b-42a1-5b33-98db-e2e12de681e8 | /course/beginners/module-1/why-keyword-search-struggles/ | Why Keyword Search Struggles | course | false | Why Keyword Search Struggles
Module 1
In its simplest form, keyword search retrieves documents by matching query terms against terms in the document. In other words, it matches the words themselves, not what they mean. It works when the query and document use the same vocabulary, but it can miss relevant results when... | [
0.024868618696928024,
-0.07068092375993729,
-0.07132982462644577,
-0.024936746805906296,
0.10802298039197922,
0.004928112495690584,
0.04363896697759628,
-0.011211366392672062,
0.07750532031059265,
-0.0056030177511274815,
0.02167060226202011,
0.015353345312178135,
0.058976393193006516,
-0.0... | |
3c8ad906-9d58-5c5e-be2c-f1a83f697d12 | /documentation/cloud-rbac/role-management/ | Role Management | Custom Roles | documentation | false | Role Management > Custom Roles
An authorized user can create their own custom roles with specific sets of permissions, giving them more control over who has what access to which resource.

### Creating a Custom Role
To create a new custom... | [
0.016856776550412178,
-0.034230511635541916,
-0.056743789464235306,
-0.049522802233695984,
0.036021459847688675,
-0.01650834083557129,
0.020411262288689613,
0.04589589685201645,
0.05791594460606575,
-0.042639654129743576,
0.032855499535799026,
0.017852574586868286,
0.08432167768478394,
-0.... |
3ca61e59-6ab9-5fa2-8256-955166f25b88 | /documentation/tutorials-build-essentials/agentic-rag-langgraph/ | Agentic RAG with LangGraph | Implementation > Imports | documentation | true | Agentic RAG with LangGraph > Implementation > Imports
Install the dependencies first. The tutorial was verified with langgraph 1.2, langchain 1.4, langchain-openai 1.6, langchain-community 0.4, and langchain-qdrant 1.1 on Python 3.12.
```bash
pip install langgraph langchain langchain-openai langchain-community langch... | [
0.02954120747745037,
-0.04835023358464241,
-0.060161489993333817,
0.0012374264188110828,
0.07608000934123993,
-0.07101164013147354,
0.039400916546583176,
0.04992903396487236,
0.03566979244351387,
-0.04123356565833092,
0.03349028900265694,
0.03378518298268318,
0.039295539259910583,
-0.02355... |
3cc431f9-86f8-58f8-be21-0e4f762c0d46 | /course/multi-vector-search/module-1/maxsim-distance/ | MaxSim Distance Metric | Understanding MaxSim Step-by-Step > The Computation Process | course | true | MaxSim Distance Metric > Understanding MaxSim Step-by-Step > The Computation Process
Let's make this concrete with an example. Consider:
- **Query**: "apple computer"
- **Document**: "Apple makes the MacBook laptop"
MaxSim formula will choose the strongest connection from the query tokens to document tokens and sum ... | [
0.030410338193178177,
-0.041985802352428436,
-0.029979107901453972,
-0.016205640509724617,
0.0817275196313858,
-0.032120391726493835,
0.04856475815176964,
0.024816354736685753,
0.049194421619176865,
-0.06198783218860626,
0.023991508409380913,
0.004312755540013313,
0.07392287254333496,
-0.0... |
3cc61f92-3d3f-5bc2-acc3-a52f08af4c27 | /course/beginners/module-1/distance-metrics/ | Comparing Meaning: Distance Metrics | Cosine Similarity | course | false | Comparing Meaning: Distance Metrics > Cosine Similarity
Cosine similarity measures the angle between two vectors. Vectors pointing in a similar direction score closer to 1. Vectors pointing in different directions score lower. It ignores vector length. For text embeddings, direction often carries more useful informati... | [
0.05694185942411423,
-0.03667411580681801,
-0.058676064014434814,
-0.03825148940086365,
0.06676536053419113,
-0.0035306389909237623,
0.04409929737448692,
0.025301264598965645,
0.08134925365447998,
-0.021030789241194725,
0.06740228831768036,
0.0011113469954580069,
0.04614866524934769,
0.019... |
3ceb7fc7-b5b0-5c0f-9ad9-87af94d73b36 | /articles/muvera-embeddings/ | MUVERA: Making Multivectors More Performant | MUVERA in FastEmbed | article | true | MUVERA: Making Multivectors More Performant > MUVERA in FastEmbed
[FastEmbed](/documentation/fastembed/) provides late interaction text (ColBERT) and multimodal (ColPali) embeddings.
Version 0.7.2 has introduced support for MUVERA embeddings which is compatible with any multi-vector representation,
and available as a... | [
0.050641585141420364,
-0.01054462231695652,
-0.029152249917387962,
-0.08051176369190216,
0.07937793433666229,
-0.03549960255622864,
0.10091805458068848,
0.0323575921356678,
0.015017915517091751,
0.021642694249749184,
0.024940690025687218,
0.035107336938381195,
0.013222118839621544,
-0.0319... |
3cfd2cda-448a-5535-94cc-030ba2dc09d6 | /articles/vector-similarity-beyond-search/ | Vector Similarity: Going Beyond Full-Text Search | Recommendations | article | false | Vector Similarity: Going Beyond Full-Text Search > Recommendations
Vector similarity can go above a single query vector.
It can combine multiple positive and negative examples for a more accurate retrieval.
This is the Recommend query from the dissimilarity examples, now used for its main purpose: positive examples pu... | [
0.04896954074501991,
-0.07320845872163773,
-0.04871273413300514,
-0.037935834378004074,
0.04694289714097977,
-0.012694006785750389,
0.11814600229263306,
0.05909711495041847,
0.07752542942762375,
-0.04286474362015724,
0.047460757195949554,
0.047248050570487976,
0.030562911182641983,
-0.0012... |
3d06fd52-7965-5db1-bdeb-ec8dc484dd04 | /documentation/manage-data/payload/ | Payload | documentation | true | Payload
One of the significant features of Qdrant is the ability to store additional information along with vectors.
This information is called `payload` in Qdrant terminology.
Qdrant allows you to store any information that can be represented using JSON.
Here is an example of a typical payload:
```json
{
"name... | [
0.016635514795780182,
-0.034514859318733215,
-0.03442596271634102,
-0.07019994407892227,
0.02218029461801052,
-0.05475948378443718,
0.0747981145977974,
0.03769974038004875,
0.09317011386156082,
-0.04216046631336212,
0.02219582535326481,
-0.0017994726076722145,
0.06246301159262657,
-0.00657... | |
3d186ccb-7b53-5ccc-acdf-71c7759dbca0 | /documentation/security/ | Security | Authentication > Granular Access API Keys > JWT Configuration | documentation | true | Security > Authentication > Granular Access API Keys > JWT Configuration
These are the available options, or **claims** in the JWT lingo. You can use them in the JWT payload to define its functionality.
- **`exp`** - The expiration time of the token. This is a Unix timestamp in seconds. The token will be invalid afte... | [
0.024327708408236504,
-0.02331022173166275,
-0.04614294692873955,
-0.05848274379968643,
0.07371390610933304,
-0.041284818202257156,
0.0463445819914341,
0.023686455562710762,
0.08239326626062393,
-0.04022441804409027,
0.034215547144412994,
0.03205641731619835,
0.07808224856853485,
-0.033738... |
3d307d21-1dd9-574c-b91d-7328f35f31f6 | /documentation/cloud-tools/ | Infrastructure Tools | documentation | false | Infrastructure Tools
## Cloud Tools
| Integration | Description |
| ----------------------------------- | ------------------------------------------------------------------------------------------- |
| [Pulumi](/do... | [
0.011527054011821747,
-0.016363656148314476,
-0.0606842003762722,
-0.054583288729190826,
0.057187605649232864,
-0.007271073758602142,
0.09200174361467361,
0.052484240382909775,
0.040554892271757126,
-0.03927858546376228,
0.028308823704719543,
-0.0160879734903574,
0.015809277072548866,
0.00... | |
3d3f806b-d045-5019-958c-094dc34540a0 | /articles/what-are-embeddings/ | Vector Embeddings Explained: How They Work in ML & Search | article | false | Vector Embeddings Explained: How They Work in ML & Search
> **Embeddings** are numerical machine learning representations of the semantics of the input data. They capture the meaning of complex, high-dimensional data, like text, images, or audio, into vectors. Enabling algorithms to process and analyze the data more e... | [
0.00803629495203495,
-0.026522981002926826,
-0.08797357976436615,
-0.05010543018579483,
0.025259148329496384,
-0.013417736627161503,
0.04165305569767952,
0.051452916115522385,
0.09597597271203995,
-0.015055829659104347,
0.01543191634118557,
0.029189519584178925,
0.05202896520495415,
-0.022... | |
3d99aafb-e83a-553f-9263-28888c35e821 | /course/multi-vector-search/module-3/evaluating-pipelines/ | Evaluating Search Pipelines | Quick Reference: Evaluation Metrics | course | false | Evaluating Search Pipelines > Quick Reference: Evaluation Metrics
Before diving in, here's the essential guide to choosing metrics. For multi-stage pipelines, focus on **Recall@k for the prefetch stage** (did we capture candidates?) and **NDCG@k for the final ranking** (did we order them correctly?).
| Metric ... | [
-0.009959959425032139,
-0.026006681844592094,
-0.025800315663218498,
-0.0066487714648246765,
0.047601886093616486,
-0.014529352076351643,
0.03533702343702316,
0.047759633511304855,
0.09127959609031677,
-0.045105915516614914,
-0.01699838601052761,
0.00911228358745575,
0.05555252358317375,
-... |
3dd22b93-0d53-574b-a5d0-b293811501d6 | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | Did we Solve the Vocabulary Mismatch Yet? > External Document Expansion | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ > Did we Solve the Vocabulary Mismatch Yet? > External Document Expansion
External document expansion uses a **generative model** (Mistral 7B, Chat-GPT, and Claude are all generative models,
generating words based on the input text) to compose additions to docum... | [
0.06719300150871277,
-0.021494397893548012,
-0.02647443488240242,
-0.041276730597019196,
0.08878704160451889,
-0.03976060822606087,
0.07896283268928528,
0.026837052777409554,
0.06697933375835419,
-0.033254384994506836,
0.03997766226530075,
-0.005399744026362896,
0.04167284443974495,
-0.027... |
3dd5820c-6dcd-5f04-b6cf-b49b21ac03a8 | /course/multi-vector-search/module-1/maxsim-distance/ | MaxSim Distance Metric | Understanding MaxSim Step-by-Step > Understanding Tokenization | course | true | MaxSim Distance Metric > Understanding MaxSim Step-by-Step > Understanding Tokenization
Before we compute MaxSim, let's understand how ColBERT tokenizes our query and document. This tokenization is crucial because each token gets its own embedding vector.
```python
query_tokenization = colbert_model.model.tokenize([q... | [
0.0646122470498085,
-0.03207866847515106,
-0.02579626627266407,
-0.022519616410136223,
0.06898175925016403,
-0.0510680228471756,
0.060771867632865906,
0.03183445334434509,
0.058125972747802734,
-0.05248357728123665,
0.042520828545093536,
0.02938246913254261,
0.06331133097410202,
-0.0403767... |
3dd64e3d-a7d2-5922-9000-a49be7a3eaae | /documentation/tutorials-develop/hybrid-search-fastembed/ | Build a Hybrid Search API | documentation | false | Build a Hybrid Search API
| Time: 20 min | Level: Beginner | Output: [GitHub](https://github.com/qdrant/qdrant_demo/) |
| --- | ----------- | ----------- |----------- |
This tutorial shows you how to build and deploy your own hybrid search service to look through descriptions of companies from [startups-list.com](htt... | [
0.03397469222545624,
-0.04028164595365524,
-0.05099426582455635,
-0.025068480521440506,
0.0956287607550621,
-0.04078909009695053,
0.0835227221250534,
0.06080922856926918,
0.048097334802150726,
-0.026227841153740883,
0.049846868962049484,
0.029011007398366928,
0.056769147515296936,
-0.05761... | |
3dddd48b-3f8d-5ddb-9b2a-6607f7f645c7 | /documentation/ops-configuration/administration/ | Administration | Strict Mode > Maximum Search Oversampling | documentation | true | Administration > Strict Mode > Maximum Search Oversampling
A high oversampling factor increases the number of candidates evaluated during search, which can significantly increase latency.
Setting `search_max_oversampling` caps the maximum oversampling factor allowed in search parameters.
```python
from qdrant_client... | [
0.017756687477231026,
-0.06990408152341843,
-0.044880710542201996,
-0.03188258036971092,
0.045634038746356964,
-0.022886989638209343,
0.07134170830249786,
0.026515377685427666,
0.08891092985868454,
-0.0468854121863842,
0.019608238711953163,
0.003129064803943038,
0.09687548130750656,
-0.038... |
3de07d41-b6e7-53e8-b929-5e9a3657d311 | /course/essentials/day-6/final-project/ | Final Project: Production-Ready Documentation Search Engine | Build Steps > Step 1: Initialize Client | course | true | Final Project: Production-Ready Documentation Search Engine > Build Steps > Step 1: Initialize Client
```python
from qdrant_client import QdrantClient, models
import os
client = QdrantClient(url=os.getenv("QDRANT_URL"), api_key=os.getenv("QDRANT_API_KEY"))
# For Colab:
# from google.colab import userdata
# client = ... | [
-0.0037869741208851337,
-0.052653826773166656,
-0.02957787550985813,
-0.03538254648447037,
0.06230340898036957,
-0.020265866070985794,
0.017802303656935692,
0.0271989107131958,
0.07000628113746643,
-0.022056693211197853,
0.03973805531859398,
0.034716248512268066,
0.07764257490634918,
-0.04... |
3de58633-c734-5ceb-9381-1de3a4818c00 | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | Naive Approaches and Their Problems | course | false | Combining Vector Search and Filtering > Naive Approaches and Their Problems
### Post-Filtering
One approach is to ignore the filter initially: run the search across the whole dataset, get the top K most similar vectors, then apply the filter afterward.
**The problem:** You might discard most of the top K results. If... | [
0.06320047378540039,
-0.07386721670627594,
-0.0484602116048336,
-0.03530267998576164,
0.08987995237112045,
-0.029804006218910217,
0.03956473991274834,
0.0006240890943445265,
0.07867088168859482,
0.012882628478109837,
0.028361564502120018,
0.0495339073240757,
0.07969502359628677,
-0.0178716... |
3decff61-ab24-5bce-8cdc-fca3fb90f8d4 | /documentation/migration-recovery-options/ | Migration and Recovery | Comparison > Overview & Use Case | documentation | false | Migration and Recovery > Comparison > Overview & Use Case
A high-level look at what each option does, the scenario it's designed for, and the granularity at which it operates.
| | Migration Tool | Snapshots | Cloud Backups |
|---|---|---|---|
| **Description** | Streams collection data to target | Captures collection... | [
0.008396901190280914,
-0.06211436167359352,
-0.03464330732822418,
-0.05575438588857651,
0.045074690133333206,
0.03711159899830818,
0.06457830220460892,
0.008606458082795143,
0.05449177697300911,
-0.025585170835256577,
0.012471512891352177,
0.008764466270804405,
0.033295489847660065,
-0.027... |
3df95d7f-6400-5fb6-b8dd-fa7e56342bdb | /course/essentials/day-7/tensorlake/ | Integrating with Tensorlake | TensorLake Knowledge Graph Integration > Real-World Applications | course | false | Integrating with Tensorlake > TensorLake Knowledge Graph Integration > Real-World Applications
This architecture enables various advanced use cases:
- **Research Discovery**: Finding relevant academic papers with complex criteria
- **Legal Document Analysis**: Processing contracts and legal documents with structured ... | [
-0.0036232229322195053,
-0.039577219635248184,
-0.09381119906902313,
0.003785953391343355,
0.08555439859628677,
-0.015738824382424355,
0.022933607921004295,
0.05010275915265083,
0.0354270413517952,
-0.025460289791226387,
0.00966759491711855,
0.017678329721093178,
0.08014362305402756,
0.016... |
3e55c736-2b93-5515-8186-961fc9765345 | /articles/immutable-data-structures/ | Immutable Data Structures in Qdrant | Updating Immutable Data Structures | article | false | Immutable Data Structures in Qdrant > Updating Immutable Data Structures
One may wonder how Qdrant allows updating collection data if everything is immutable.
Indeed, [Qdrant API](https://api.qdrant.tech) allows the change of any vector or payload at any time, so from the user's perspective, the whole collection is mu... | [
0.053612370043992996,
-0.03904861956834793,
-0.05927916243672371,
-0.019871439784765244,
0.06459549814462662,
-0.04442976042628288,
0.06800694018602371,
0.052715692669153214,
0.07045303285121918,
-0.04713547229766846,
-0.013360133394598961,
0.02612517960369587,
0.06035853549838066,
-0.0298... |
3e6d94d5-867a-59e4-b02f-fb750c456ab4 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantClusterList | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantClusterList
QdrantClusterList contains a list of QdrantCluster
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `apiVersion` _string_ | `qdrant.io/v1` | | |
| `kind` _string_ | `QdrantClusterList` | | |
| `metadata` _[ListMeta](https://ku... | [
0.037012677639722824,
-0.02122078463435173,
-0.0326891764998436,
-0.06630799174308777,
0.06761328130960464,
-0.07311230897903442,
0.06349526345729828,
0.07155349850654602,
0.05072629451751709,
-0.0622224286198616,
0.05696827173233032,
0.020238250494003296,
0.04764185845851898,
0.0037030307... |
3e917a18-ff16-52ea-8f89-590a290d9a3d | /documentation/migrate-to-qdrant/from-weaviate/ | From Weaviate | Run the Migration | documentation | true | From Weaviate > Run the Migration
```bash
docker run --net=host --rm -it registry.cloud.qdrant.io/library/qdrant-migration weaviate \
--weaviate.host 'your-weaviate-host.example.com' \
--weaviate.scheme https \
--weaviate.class-name 'YourClass' \
--weaviate.auth-type apiKey \
--weaviate.api-key 'yo... | [
0.09394905716180801,
-0.012411593459546566,
-0.060890719294548035,
-0.11290764808654785,
0.05467834696173668,
-0.005164680071175098,
0.021393928676843643,
0.010583215393126011,
-0.01870695874094963,
-0.017330780625343323,
0.04651876538991928,
0.004057558719068766,
0.029467273503541946,
0.0... |
3eaab89d-adff-5ea4-b2ba-2ebd346a601d | /documentation/ops-configuration/quotas/ | Resource Quotas | Release Margin | documentation | true | Resource Quotas > Release Margin
A limit trips as soon as usage reaches it, but only clears once usage has fallen `release_margin_percent` percentage points below it. With the default margin of 5, a node with `max_disk_usage_percent` set to 90 stops taking writes at 90% and starts again below 85%.
Changing the quota ... | [
0.005796118639409542,
-0.0617637000977993,
-0.014676219783723354,
-0.03969614952802658,
0.06606979668140411,
-0.023477530106902122,
0.013579568825662136,
0.0370536670088768,
0.07855833321809769,
-0.04379957169294357,
0.028298785910010338,
0.024111999198794365,
0.055189210921525955,
-0.0548... |
3ec7dd1c-49d5-5a53-a551-b8ff3e72259a | /documentation/tutorials-build-essentials/agentic-rag-camelai-discord/ | Discord RAG Bot | Run in Colab or Locally | documentation | false | Discord RAG Bot > Run in Colab or Locally
The [Colab notebook](https://colab.research.google.com/github/qdrant/examples/blob/update-discord-bot/disord-bot/discord_rag_bot.ipynb) runs the same code with the same dependency pins as this page. Open it on a CPU runtime, enter your keys at the hidden prompts, and run the c... | [
0.01619558222591877,
-0.025299284607172012,
-0.00946207158267498,
-0.018918616697192192,
0.08232912421226501,
-0.020364277064800262,
0.04944270849227905,
0.04082396999001503,
0.04692979156970978,
-0.019913550466299057,
0.017654092982411385,
-0.012619425542652607,
0.06654459983110428,
-0.02... |
3ef33c10-7db9-5898-8a6d-067fdd17b318 | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Two Options > Option 1: Blue-Green Migration | documentation | false | Migrate to a New Embedding Model > Two Options > Option 1: Blue-Green Migration
The [blue-green migration approach](#blue-green-migration) uses two parallel collections. Start by creating a new collection configured for the new embedding model. Then, enable dual writes such that every incoming upsert is written to bot... | [
0.042818088084459305,
-0.06107918918132782,
-0.03840678930282593,
-0.03266608342528343,
0.07178421318531036,
-0.011207779869437218,
0.04909338802099228,
0.043739598244428635,
0.03272416815161705,
-0.017104117199778557,
0.000850701006129384,
0.03404237702488899,
0.013125370256602764,
-0.011... |
3ef7c732-0590-5478-9333-6485a4113b8a | /course/multi-vector-search/module-3/quantization-techniques/ | Vector Quantization Techniques | Quantization: Compressing Without Losing Quality > Binary Quantization: Maximum Compression | course | false | Vector Quantization Techniques > Quantization: Compressing Without Losing Quality > Binary Quantization: Maximum Compression
For ColModernVBERT's **128 dimensions**, binary quantization presents unique challenges. With such low dimensionality, each bit of precision has a larger impact on the representation. The choice... | [
0.03673246130347252,
-0.025455735623836517,
-0.031998757272958755,
-0.051241301000118256,
0.04621776565909386,
-0.023211779072880745,
0.04132162407040596,
0.06454440206289291,
0.10210639238357544,
-0.036011893302202225,
0.035714343190193176,
0.007546951994299889,
0.04965151846408844,
-0.03... |
3f115afd-3113-51ab-9c5b-7765933553f5 | /documentation/embeddings/jina-embeddings/ | Jina AI | Setup | documentation | true | Jina AI > Setup
Jina AI has no official Python or TypeScript SDK, so these examples call its REST API with `requests` and `fetch`. Install the HTTP client and the Qdrant client:
- Python: `pip install requests qdrant-client`
- TypeScript: `npm install @qdrant/js-client-rest`
Create a helper for the Embedding API, th... | [
0.027502618730068207,
-0.035097282379865646,
0.0027139296289533377,
-0.03767773136496544,
0.06666000932455063,
-0.03812607005238533,
0.05844391882419586,
0.051719021052122116,
0.04335934296250343,
-0.019945060834288597,
0.07118909060955048,
0.020671697333455086,
0.06679443269968033,
-0.052... |
3f1480b2-12a3-5072-a76e-39b599d8eb62 | /articles/minicoil-en-es/ | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier | From Words to Concepts > One Slot per Concept | article | false | miniCOIL EN-ES: Sparse Neural Retrieval Across the Language Barrier > From Words to Concepts > One Slot per Concept
While in miniCOIL v1, every English word in a 30k vocabulary got its own trainable layer-model and its own 4 consecutive cells-dimensions in the sparse vector, in miniCOIL EN-ES, every *concept* gets one... | [
0.047563087195158005,
-0.039223045110702515,
-0.023047376424074173,
-0.05202970653772354,
0.0658525750041008,
-0.049129288643598557,
0.05547032877802849,
0.028458282351493835,
0.06268040090799332,
-0.040773309767246246,
0.006726417224854231,
0.03831372782588005,
0.08358326554298401,
0.0091... |
3f29d12c-1e48-5252-a29c-38772ce70974 | /course/essentials/day-4/what-is-quantization/ | Vector Quantization Methods | Dual Storage Architecture | course | false | Vector Quantization Methods > Dual Storage Architecture
Qdrant's quantization implementation maintains both compressed and original vectors, enabling flexible deployment strategies and safe experimentation. This dual storage approach allows you to switch quantization methods, adjust parameters, or disable quantization... | [
0.03842255473136902,
-0.06317314505577087,
-0.05384250730276108,
-0.03986012190580368,
0.05832868069410324,
-0.007643015123903751,
0.05335327237844467,
0.010244598612189293,
0.0918755754828453,
-0.008518287912011147,
-0.0026862341910600662,
0.019837824627757072,
0.06534960120916367,
-0.012... |
3f469106-4574-5b42-980b-5447d2f39e5a | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Implementing Vector Search with Reranking > Implementation > Vector Search | documentation | true | Reranking for Better Search > Implementing Vector Search with Reranking > Implementation > Vector Search
This snippet grabs the top 10 most relevant points from your Qdrant collection using the query embedding.
```python
search_result = client.query_points(
collection_name="basic-search-rerank", query=query_embed... | [
0.044902753084897995,
-0.07608596235513687,
-0.03883553296327591,
-0.014129476621747017,
0.04978816956281662,
-0.061142709106206894,
0.06296208500862122,
0.026316793635487556,
0.07821107655763626,
-0.010776651091873646,
0.037772901356220245,
0.043324388563632965,
0.028826944530010223,
-0.0... |
3f486490-dcd6-57bf-9638-18b2b759d42d | /documentation/tutorials-search-engineering/slicing-filter/ | Deterministic Collection Slicing | Reproducible Sampling | documentation | true | Deterministic Collection Slicing > Reproducible Sampling
Because the hash is stable across runs and Qdrant versions, a single slice makes a reproducible sample: requesting slice `0` of `total: 10` always returns the same 10% of the collection. [Random sampling](/documentation/search/search/#random-sampling) cannot mak... | [
0.02276693657040596,
-0.03770475462079048,
-0.03910760581493378,
-0.06990022957324982,
0.05807695910334587,
-0.02623489685356617,
0.05788099020719528,
0.01650337688624859,
0.0940658301115036,
-0.0321575291454792,
0.0343584343791008,
0.024688290432095528,
0.05990484729409218,
-0.01879041828... |
3f48c5ee-85d6-5c9a-87da-f9f7e939f407 | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | Implementing Multi-Modal Search with FastEmbed and Qdrant > Processing Images and Understanding Embeddings | course | true | How ColPali Models Work > Implementing Multi-Modal Search with FastEmbed and Qdrant > Processing Images and Understanding Embeddings
Now let's process a document image through ColPali to see the multi-vector embeddings in action:
```python
from PIL import Image
image = Image.open("images/einstein-newspaper.jpg")
ima... | [
0.04382069408893585,
-0.025892727077007294,
-0.051087141036987305,
-0.036086227744817734,
0.08970579504966736,
-0.023319022729992867,
0.04879828914999962,
0.03192354738712311,
0.04774191230535507,
-0.028041474521160126,
0.03787415847182274,
0.013818171806633472,
0.058987654745578766,
-0.04... |
3f505b40-82e2-5afb-a352-4742f7355f6d | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Deploy Behind a Load Balancer | documentation | false | Distributed Deployment > Deploy Behind a Load Balancer
In a multi-node Qdrant cluster, every node can accept requests and route them internally to the correct shards. To get the best performance and availability out of your cluster, distribute requests evenly across all nodes by routing requests through a load balance... | [
0.02457815781235695,
-0.04138590767979622,
-0.04675319045782089,
-0.033513180911540985,
0.08102260529994965,
-0.02497006766498089,
0.05453919619321823,
0.03645728901028633,
0.06719927489757538,
-0.03298084810376167,
0.04602736234664917,
0.03332584351301193,
0.02051336131989956,
-0.00470759... |
3f66c86e-b27b-5eab-ab23-b9d4d3d5dddc | /documentation/search-tuning/when-your-collection-outgrows-ram/ | When Your Collection Outgrows RAM | Verify It on Your Own Collection | documentation | true | When Your Collection Outgrows RAM > Verify It on Your Own Collection
Configure the bit depth and the two placements on the collection you already have, using the name of your dense vector. `rescore` and `oversampling` belong on the query, which is what makes them cheap to compare.
```python
from qdrant_client import ... | [
0.04304764047265053,
-0.058771539479494095,
-0.037454620003700256,
-0.040043704211711884,
0.06047965586185455,
-0.021964075043797493,
0.0365264005959034,
0.045251891016960144,
0.09058671444654465,
-0.028899235650897026,
0.017729870975017548,
0.01784449629485607,
0.04020630568265915,
-0.006... |
3f715117-f5ee-52d2-aa2f-1a33b5049735 | /documentation/search-tuning/how-to-tune-hybrid-search/ | How to Tune Hybrid Search in Qdrant | documentation | false | How to Tune Hybrid Search in Qdrant
Before you tune fusion, use the [pre-tuning checks](/documentation/search-tuning/before-tuning-a-qdrant-collection/) to verify index state and set a labeled baseline.
Hybrid search retrieves dense and sparse candidate lists, then fuses them into one ranking. The dense prefetch find... | [
0.041737575083971024,
-0.054183416068553925,
-0.05418112874031067,
-0.05703224986791611,
0.0596277229487896,
-0.03507957234978676,
0.06835468858480453,
0.020054807886481285,
0.05215485021471977,
-0.012939936481416225,
0.042645663022994995,
0.021076681092381477,
0.05262741819024086,
-0.0113... | |
3f7b38ca-265f-53f8-9ade-1d2bf58ea413 | /documentation/edge/edge-api/updating-data/ | Updating Data | documentation | false | Updating Data
Every write to an Edge Shard goes through a single method, `update`, which takes one `UpdateOperation` describing what to change. The operation is written to the write-ahead log before it is applied to storage, so an update that has returned survives a crash. | [
-0.012888084165751934,
-0.051290687173604965,
-0.06320003420114517,
-0.04840770363807678,
0.0684707760810852,
-0.014995260164141655,
0.031139906495809555,
0.0179915614426136,
0.04738318547606468,
-0.013721046037971973,
0.014947481453418732,
0.055023882538080215,
0.044520970433950424,
-0.02... | |
3f8be6ac-946a-5a6b-a5a1-96a9552cbfbf | /articles/bm42/ | BM42: Attention-Based Sparse Embeddings for Hybrid Search | The best of both worlds > WordPiece retokenization | article | true | BM42: Attention-Based Sparse Embeddings for Hybrid Search > The best of both worlds > WordPiece retokenization
The final piece of the puzzle we need to solve is the tokenization issue. In order to get attention vectors, we need to use native transformer tokenization.
But this tokenization is not suitable for the retri... | [
0.06740441918373108,
-0.02105478197336197,
-0.02376457303762436,
-0.06194104999303818,
0.07224974781274796,
-0.04703643545508385,
0.038392916321754456,
-0.0051364777609705925,
0.04665123298764229,
-0.0029806774109601974,
0.037764064967632294,
0.04220842197537422,
0.04478179290890694,
-0.03... |
3fa8b3de-a21f-56a9-b183-a7778add999a | /course/multi-vector-search/module-3/multi-stage-retrieval/ | Multi-Stage Retrieval with Universal Query API | When to Use Multi-Stage Retrieval | course | false | Multi-Stage Retrieval with Universal Query API > When to Use Multi-Stage Retrieval
Multi-stage retrieval is valuable for **large collections** (100K+ documents) where you need **fast queries** while maintaining **multi-vector quality**. It's particularly effective when combining different embedding models or optimizin... | [
0.0044837696477770805,
-0.03603362292051315,
-0.01226238626986742,
-0.026877902448177338,
0.041852083057165146,
-0.04305326193571091,
0.03855857253074646,
-0.000048241086915368214,
0.08625885099172592,
-0.03171825781464577,
-0.0008815782493911684,
0.023890800774097443,
0.05937841162085533,
... |
3fb037eb-6015-51e7-aabf-782e00a091dc | /documentation/migrate-to-qdrant/from-elasticsearch/ | From Elasticsearch | What You Need from Elasticsearch | documentation | false | From Elasticsearch > What You Need from Elasticsearch
- **Elasticsearch URL** — the HTTP endpoint
- **Index name** — the index containing your vectors
- **Credentials** — username/password or API key | [
0.003655447391793132,
-0.06084524467587471,
-0.07009422034025192,
-0.01155322976410389,
0.023989969864487648,
-0.02189335785806179,
0.043263744562864304,
0.01841564290225506,
0.055812206119298935,
-0.02862546406686306,
0.01637517847120762,
0.02498549222946167,
0.06691082566976547,
-0.05606... |
3fb17de0-9889-549b-9b52-48195d191e83 | /documentation/embeddings/gemini/ | Gemini | Embed Queries | documentation | true | Gemini > Embed Queries
Queries get a different prefix from documents. `task: search result | query: ...` tells the model that this text is a search query, while the `title: ... | text: ...` prefix marks the documents it should match:
```python
query_response = gemini_client.models.embed_content(
model=MODEL,
... | [
0.03883056715130806,
-0.05527450516819954,
-0.07077796012163162,
-0.010560771450400352,
0.05428893491625786,
-0.018153512850403786,
0.03526122868061066,
0.03944176435470581,
0.045596007257699966,
-0.004947332665324211,
0.010586670599877834,
0.00272040581330657,
0.05531635507941246,
-0.0156... |
3fb435bb-f1f1-5c96-a0fd-dfa66c19a5c7 | /documentation/manage-data/indexing/ | Indexing | Full-Text Index > Tokenizers > Prefix | documentation | false | Indexing > Full-Text Index > Tokenizers > Prefix
The `prefix` tokenizer splits the string into words, separated by spaces, punctuation marks, and special characters, and then creates a prefix index for each word. For example, `hello` is indexed as `h`, `he`, `hel`, `hell`, and `hello`. | [
0.00936377327889204,
-0.012080179527401924,
-0.018157046288251877,
-0.043995365500450134,
0.07786841690540314,
-0.04224282503128052,
-0.003377612680196762,
0.041603393852710724,
0.06663931906223297,
-0.02192380279302597,
0.036857929080724716,
0.0327613465487957,
0.0508861280977726,
-0.0152... |
402a5532-7caf-5489-8ac2-5f6a87fd4ccc | /documentation/examples/hybrid-search-llamaindex-jinaai/ | Chat With Product PDF Manuals Using Hybrid Search | Parse the PDFs With LlamaParse | documentation | true | Chat With Product PDF Manuals Using Hybrid Search > Parse the PDFs With LlamaParse
The `llama-cloud` SDK uploads each PDF and waits for the parsing job to finish.
`expand=["markdown"]` includes Markdown pages in the returned result. This example
uses `tier="cost_effective"` and `version="latest"`; the service's latest... | [
0.036216482520103455,
-0.06002053618431091,
-0.030027709901332855,
-0.08539023250341415,
0.06995873153209686,
-0.02662772499024868,
0.05951559171080589,
0.026717977598309517,
0.07368020713329315,
-0.036170389503240585,
-0.02794499881565571,
0.06413647532463074,
0.009370340965688229,
-0.043... |
404a8b82-35d3-5f35-bf34-59cc3215fbfc | /documentation/capacity-planning/ | Capacity Planning | Calculating RAM and Disk Size > Dense Vectors > Original Vectors | documentation | true | Capacity Planning > Calculating RAM and Disk Size > Dense Vectors > Original Vectors
[Dense vectors](/documentation/manage-data/vectors/#dense-vectors) are the original representations of the embeddings you search over. The amount of RAM and disk they consume depends on the base number, the vector dimensionality, and ... | [
0.011023296043276787,
-0.04321018233895302,
-0.04101591929793358,
-0.03725835680961609,
0.05856836587190628,
-0.023725319653749466,
0.04613800346851349,
0.08160637319087982,
0.1169358491897583,
-0.012189241126179695,
0.018318437039852142,
0.04347128048539162,
0.02759401686489582,
-0.021304... |
409c6a3c-65d0-5fb3-85ec-920688065655 | /documentation/quickstart/ | Local Quickstart | Create a collection | documentation | true | Local Quickstart > Create a collection
You will be storing all of your vector data in a Qdrant collection. Let's call it `test_collection`. This collection will be using a dot product distance metric to compare vectors.
```python
from qdrant_client.models import Distance, VectorParams
client.create_collection(
c... | [
0.047165896743535995,
-0.04490603506565094,
-0.019265305250883102,
-0.025077110156416893,
0.0465860590338707,
-0.03265251964330673,
0.06511544436216354,
0.03742825612425804,
0.1069086492061615,
-0.0343894362449646,
0.03290976583957672,
0.03667286038398743,
0.0762912929058075,
-0.0124269472... |
40a6a779-db72-5397-a63d-af7cb28fd834 | /documentation/examples/rag-contract-management-stackit-cohere/ | Region-Specific Contract Management System | Implementation > Search application > Check the access restrictions | documentation | true | Region-Specific Contract Management System > Implementation > Search application > Check the access restrictions
Before adding the LLM, make sure the filter does its job. The question is the same in all three calls, only the roles of the user change:
```python
question = "What are the rules of performing the audit?"
... | [
0.0057678623124957085,
-0.05371641367673874,
-0.061955902725458145,
-0.0301342885941267,
0.027466394007205963,
-0.032932400703430176,
0.03408665210008621,
0.0661020427942276,
0.07962200045585632,
-0.008385000750422478,
0.003616499947384,
0.022107809782028198,
0.07306277751922607,
-0.045986... |
40ad61a6-b205-5185-8868-d42010f3e320 | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 2: Statistical Sampling (Recommended) > Tier 2 Pass/Fail Criteria | documentation | false | Search Quality > Tier 2: Statistical Sampling (Recommended) > Tier 2 Pass/Fail Criteria
| Metric | Pass | Investigate | Fail |
| ----- | ----- | ----- | ----- |
| Mean recall@10 | ≥0.85 | 0.70 to 0.85 | <0.70 |
| Median recall@10 | ≥0.90 | 0.75 to 0.90 | <0.75 |
| Min recall@10 | ≥0.50 | 0.30 to 0.50 | <0.30 |
| P5 re... | [
0.008196250535547733,
-0.02713259682059288,
-0.030528411269187927,
-0.012501872144639492,
0.03910646215081215,
-0.02069641277194023,
0.04707188904285431,
0.056777480989694595,
0.09921601414680481,
-0.03344937786459923,
0.031088123098015785,
0.03228941187262535,
0.0360267274081707,
-0.01693... |
40ae5ad8-3fc4-54f9-ac9c-9be5133fdb6b | /course/essentials/day-1/embedding-models/ | Points, Vectors and Payloads | Common Embedding Sources | course | false | Points, Vectors and Payloads > Common Embedding Sources
Choosing the right embedding source is a critical decision that balances cost, performance, and accuracy. Here are the three primary approaches. | [
0.02682141773402691,
-0.027148226276040077,
-0.01800062134861946,
-0.07053187489509583,
0.0037489808164536953,
-0.009541814215481281,
0.0840580016374588,
0.059490546584129333,
0.06291869282722473,
-0.03131183981895447,
0.02923792041838169,
0.01764846406877041,
0.031872011721134186,
-0.0344... |
40d7a756-2dab-5779-8d5e-2fcf23b6dd18 | /course/essentials/day-7/llamaindex/ | Integrating with LlamaIndex | LlamaIndex Agent Development Framework > Real-World Applications | course | false | Integrating with LlamaIndex > LlamaIndex Agent Development Framework > Real-World Applications
This architecture enables various sophisticated use cases:
- **Knowledge Management**: Building intelligent knowledge bases with dynamic content updates
- **Document Processing**: Advanced document parsing and search system... | [
-0.017656797543168068,
-0.02559480257332325,
-0.08239828795194626,
-0.030835134908556938,
0.09973110258579254,
-0.02247072570025921,
0.0405019111931324,
0.024611059576272964,
0.054028891026973724,
-0.04631521552801132,
0.02204444631934166,
0.0019483964424580336,
0.03168485313653946,
0.0009... |
40e4d223-9a1e-54dd-97f8-08f91e537e22 | /documentation/production-operations/managed-cloud-prometheus/ | Managed Cloud Prometheus Monitoring | Prerequisites | documentation | false | Managed Cloud Prometheus Monitoring > Prerequisites
This tutorial assumes that you already have a Kubernetes cluster running where you want to deploy your monitoring stack, and a Qdrant database created in Qdrant Managed Cloud. You should also have `kubectl` and `helm` configured to interact with your cluster. | [
-0.0009872026275843382,
-0.03212020918726921,
-0.052620779722929,
-0.031117381528019905,
0.04311991482973099,
-0.03202312812209129,
0.07033728808164597,
0.03460162505507469,
0.0559111163020134,
-0.029448041692376137,
0.04538620263338089,
0.011637387797236443,
0.07701308280229568,
-0.021704... |
412b5264-4f6c-58b3-93ff-0bc2430a1db2 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Migrating > Legacy Settings > Dense Vectors | documentation | false | Memory Tiers > Migrating > Legacy Settings > Dense Vectors
The legacy parameter is `on_disk`.
| `memory` | Legacy value |
|---|---|
| `cached` | `on_disk: false` |
| `cold` | `on_disk: true` | | [
0.023078439757227898,
-0.0389598123729229,
-0.001637666835449636,
-0.036664243787527084,
0.045070797204971313,
-0.015230266377329826,
0.02585258148610592,
0.06590832024812698,
0.055512577295303345,
-0.06358710676431656,
0.005548173561692238,
0.04434504732489586,
0.05139448493719101,
-0.005... |
413c4d93-9ae9-503b-82ed-42cf3ae32220 | /documentation/tutorials-operations/data-streaming-kafka-qdrant/ | Kafka Streaming into Qdrant | Qdrant | documentation | false | Kafka Streaming into Qdrant > Qdrant
The processed data is then routed to **Qdrant**, a highly scalable vector search engine designed for similarity searches. Qdrant excels at managing and searching through high-dimensional vector data, which is essential for applications involving machine learning and AI, such as rec... | [
0.06038467213511467,
-0.06314025819301605,
-0.07400458306074142,
-0.023724736645817757,
0.07029154151678085,
-0.017783166840672493,
0.07715333253145218,
-0.0008426118292845786,
0.062032606452703476,
-0.03094886988401413,
0.04135459288954735,
0.0005091248312965035,
0.05175500363111496,
-0.0... |
414be470-f17c-5a78-afcf-fa5a26c927fd | /documentation/deploy-intro/ | Deploy Qdrant | Self-Hosted | documentation | false | Deploy Qdrant > Self-Hosted
- [Installation](/documentation/installation/index.md) — Install Qdrant via Docker, Kubernetes, or binary on Linux, macOS, or Windows.
- [Distributed Deployment](/documentation/scaling/distributed_deployment/index.md) — Multi-node clusters with horizontal sharding and replication for scale ... | [
0.022804763168096542,
-0.06465283036231995,
-0.0498475544154644,
-0.05255328118801117,
0.08910594880580902,
-0.032492443919181824,
0.07513713836669922,
0.020566651597619057,
0.0596095509827137,
-0.03377912938594818,
0.04548211023211479,
-0.016134219244122505,
0.03746027126908302,
-0.046262... |
415e0a5b-1e3c-52b7-9cfa-56f65d47c00c | /documentation/ops-configuration/usage-statistics/ | Usage Statistics | documentation | false | Usage Statistics
The Qdrant open-source container image collects anonymized usage statistics from users in order to improve the engine by default. You can [deactivate](#deactivate-usage-statistics) at any time, and any data that has already been collected can be [deleted on request](#request-information-deletion).
D... | [
0.05496343597769737,
-0.031266048550605774,
-0.014372255653142929,
-0.03070780634880066,
0.014046803116798401,
-0.008722793310880661,
0.05422813445329666,
0.04371510446071625,
0.0702081173658371,
-0.034835513681173325,
0.05444253981113434,
0.0012049583019688725,
0.08651993423700333,
-0.026... | |
41629d9d-355b-556d-b9b0-71a07585a97c | /documentation/scaling/horizontal-scaling/ | Horizontal Scaling | How Many Qdrant Nodes Should I Run? > Three or More Nodes | documentation | false | Horizontal Scaling > How Many Qdrant Nodes Should I Run? > Three or More Nodes
Three nodes or more provide a highly available cluster, as long as the replication factor is two or higher. Clusters with three or more nodes and replication can perform all operations even while one node is down. They also gain performance... | [
-0.012465490028262138,
-0.004266198258846998,
-0.049215734004974365,
-0.05431731790304184,
0.07007346302270889,
-0.04325152561068535,
0.06459549814462662,
0.06414051353931427,
0.07832565903663635,
-0.04111696779727936,
0.03884079307317734,
0.009666696190834045,
0.03311242163181305,
-0.0357... |
4166f2ce-0778-55d0-a721-84e47fa843d7 | /course/essentials/day-2/collection-tuning-demo/ | Demo: HNSW Performance Tuning | course | false | Demo: HNSW Performance Tuning
Day 2
Learn how to improve vector search speed with [HNSW](https://qdrant.tech/articles/filterable-hnsw/) tuning and payload indexing on a real 100K dataset.
**Follow along in Colab:** | [
0.04515104368329048,
-0.01680893450975418,
-0.051739245653152466,
-0.018078602850437164,
0.049870818853378296,
-0.04193296283483505,
0.023795276880264282,
0.027654923498630524,
0.06842158734798431,
-0.021636079996824265,
0.017886724323034286,
0.03437454253435135,
0.06344452500343323,
-0.02... | |
41723429-e89c-59a6-9fdf-8602f8a2344b | /documentation/edge/edge-api/updating-data/ | Updating Data | update | documentation | true | Updating Data > update
```python
def update(self, operation: UpdateOperation) -> None
```
| Parameter | Description |
| --- | --- |
| `operation` | The operation to apply. |
**Returns** nothing in Python. In Rust, returns `Ok(())` on success.
Creating a named vector that already exists with different parameters fai... | [
0.05728685483336449,
-0.051964856684207916,
-0.026222335174679756,
-0.02745366096496582,
0.0888853669166565,
-0.018026135861873627,
0.03184571489691734,
-0.015581057406961918,
0.05629990994930267,
-0.014361044391989708,
0.022079426795244217,
0.05521770939230919,
0.04179428517818451,
-0.023... |
4179e044-c3fc-5ff5-a507-dcbc96c3fe53 | /documentation/embeddings/nomic/ | Nomic | Next Steps | documentation | false | Nomic > Next Steps
- [Use named vectors](/documentation/manage-data/vectors/#named-vectors) to keep text and image vectors on the same points.
- [Learn more about FastEmbed](/documentation/fastembed/) and the other models it runs locally.
- Read the Nomic documentation on [text embeddings](https://docs.nomic.ai/atlas/... | [
0.059089574962854385,
-0.06022897735238075,
-0.03198138251900673,
-0.04224663972854614,
0.057638805359601974,
-0.03461569547653198,
0.056706808507442474,
-0.011199521832168102,
0.024947863072156906,
-0.003433057339861989,
0.035543426871299744,
0.02329535223543644,
0.05949675664305687,
-0.0... |
41834e34-8fb5-56ca-8e15-cd798bf9efb9 | /documentation/hybrid-cloud/ | Hybrid Cloud | documentation | false | Hybrid Cloud
Seamlessly deploy and manage your vector search across diverse environments, ensuring performance, security, and cost efficiency for AI-driven applications.
[Qdrant Hybrid Cloud](/hybrid-cloud/) integrates Kubernetes clusters from any setting - cloud, on-premises, or edge - into a unified, enterprise-gra... | [
0.022014779970049858,
-0.025483377277851105,
-0.07060317695140839,
-0.04323944076895714,
0.047802045941352844,
-0.021044980734586716,
0.09373932331800461,
0.033391546458005905,
0.0627264603972435,
-0.024741290137171745,
0.017490122467279434,
-0.00450069410726428,
0.03378423675894737,
-0.01... | |
4184aa6e-d2b1-5fb1-85f7-e2214762972a | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Blue-Green Migration > Step 5: Wrapping Up | documentation | false | Migrate to a New Embedding Model > Blue-Green Migration > Step 5: Wrapping Up
Once your application has switched to the new collection, keep the dual-write mode from Step 2 running for an observation period. While the old collection still receives every write, you can roll back at any time by pointing the alias (or th... | [
0.04593489691615105,
-0.056121885776519775,
-0.012563184835016727,
-0.016477802768349648,
0.06351100653409958,
-0.03337758406996727,
0.007858599536120892,
0.05649714171886444,
0.03377944603562355,
-0.017376108095049858,
0.027457023039460182,
0.03730320930480957,
0.030542751774191856,
-0.03... |
4187f6c6-ff9b-569e-8333-3807705d3cd0 | /documentation/search-patterns/choose-embedding-model/ | How to Choose an Embedding Model: Evaluation & Tradeoffs | Evaluation: The Holy Grail of Vector Search > Checklist of Things to Consider | documentation | false | How to Choose an Embedding Model: Evaluation & Tradeoffs > Evaluation: The Holy Grail of Vector Search > Checklist of Things to Consider
Nevertheless, the evaluation does not focus on the input tokens only. First and foremost, we should measure how well
a particular model can handle the task we want to use it for. Vec... | [
0.05058610811829567,
-0.03074011765420437,
-0.05885637179017067,
-0.0530359260737896,
0.046671513468027115,
-0.03363100066781044,
0.06267149746417999,
0.004254719242453575,
0.10073255002498627,
-0.03707396611571312,
0.029428264126181602,
-0.002340369625017047,
0.06533880531787872,
-0.06301... |
419cb0fa-99d0-5f41-91d0-647f296ebeec | /documentation/cloud/configure-cluster/ | Configure Clusters | Adding Labels to a Cluster | documentation | false | Configure Clusters > Adding Labels to a Cluster
You can add labels to a Qdrant Cluster from the cluster's detail page. Labels are key-value pairs that help you organize and manage your clusters. You can also configure which label will be used for cost attribution and shown in consumption reports.
. This is one of the free embedding models available ... | [
0.06188752502202988,
-0.023371638730168343,
-0.03975364565849304,
-0.04645390808582306,
0.044320546090602875,
-0.007470305543392897,
0.09030207991600037,
0.03770916536450386,
0.04597797244787216,
-0.01264797430485487,
0.03304837644100189,
0.01567820832133293,
0.046941958367824554,
-0.03362... | |
41bb9df4-117a-5aad-a31c-509b21cf67d6 | /documentation/production-operations/memory-tiers/ | Memory Tiers in Qdrant: What to Use and When | Adjacent Work | documentation | false | Memory Tiers in Qdrant: What to Use and When > Adjacent Work
- [Memory tiers documentation](/documentation/ops-configuration/memory-tiers/): the full set of tier and quantization options per structure.
- [Storage documentation](/documentation/manage-data/storage/): how collections, segments, and storage structures fit... | [
0.010032995603978634,
-0.021242471411824226,
-0.04639118164777756,
-0.04514395073056221,
0.016148705035448074,
-0.0293516106903553,
0.056932300329208374,
0.08112594485282898,
0.1051231250166893,
-0.035196900367736816,
-0.009275015443563461,
-0.004777869675308466,
0.05354255437850952,
-0.03... |
42021ff7-b120-537f-82b6-ec13b8d63819 | /documentation/tutorials-develop/code-search/ | Semantic Search for Code | Querying the codebase | documentation | true | Semantic Search for Code > Querying the codebase
| module | file_name | score | signature ... | [
0.04481765627861023,
-0.04920108616352081,
-0.03735785186290741,
-0.027753455564379692,
0.04195057973265648,
-0.014111660420894623,
0.06873835623264313,
0.021335437893867493,
0.051057636737823486,
-0.01710718870162964,
0.07822996377944946,
0.02141202986240387,
0.025926878675818443,
-0.0351... |
422f220c-653e-50d5-856a-8e4193de4fba | /course/essentials/day-4/large-scale-ingestion/ | Large-Scale Data Ingestion | The Upload Process | course | true | Large-Scale Data Ingestion > The Upload Process
Hand the method an iterable and it takes care of the requests. Because it accepts an iterator, you can feed it a generator that reads from disk as it goes, rather than materializing the whole set first.
```python
import tqdm
client.upload_collection(
collection_nam... | [
-0.011502521112561226,
-0.003783819265663624,
-0.06969445943832397,
-0.032154228538274765,
0.08213412016630173,
-0.012528770603239536,
0.04237633943557739,
0.008107110857963562,
0.08247172832489014,
-0.026041386649012566,
0.012857521884143353,
0.034829411655664444,
0.02725398726761341,
-0.... |
423d710d-4783-5425-9b06-d1470ce98cd3 | /documentation/manage-data/multitenancy/ | Multitenancy | Tiered Multitenancy | documentation | false | Multitenancy > Tiered Multitenancy
*Available as of v1.16.0*
In some real-world applications, tenants aren't always equally distributed. For example, a SaaS application might have a few large customers and many small ones.
Large tenants might require more resources and isolation, while small tenants shouldn't add too... | [
0.013389783911406994,
-0.012435363605618477,
-0.06139563024044037,
-0.01883399672806263,
0.05141022801399231,
-0.051838018000125885,
0.059080738574266434,
0.02608947828412056,
0.08423370867967606,
-0.0009144605719484389,
0.027783511206507683,
0.02508813887834549,
0.049747105687856674,
-0.0... |
42471a45-0312-5b6f-be1e-a052af1e98bb | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Introduction to GraphRAG > Challenges of GraphRAG | documentation | false | GraphRAG with Qdrant and Neo4j > Introduction to GraphRAG > Challenges of GraphRAG
Despite its advantages, the LLM-centric GraphRAG approach faces several challenges:
- **KG Construction with LLMs:** Since the LLM is responsible for constructing the knowledge graph, there are risks such as inconsistencies, propagatio... | [
0.004707770422101021,
-0.06218404322862625,
-0.06529325246810913,
-0.040391575545072556,
0.08050843328237534,
-0.038766343146562576,
0.039890311658382416,
0.05466022342443466,
0.0747523158788681,
-0.02092144265770912,
0.033487625420093536,
-0.007271524053066969,
0.07163355499505997,
-0.020... |
42677058-16b2-564c-9423-070a95d6b4e1 | /documentation/search-patterns/vector-search-filtering/ | Filtering in Vector Search: When to Use What | Quick Reference | documentation | false | Filtering in Vector Search: When to Use What > Quick Reference
| Situation | What to do | Details |
|---|---|---|
| You filter on a field in dense vector search | Create a payload index on it, before you ingest data | [Index Every Field You Filter On](#index-every-field-you-filter-on) |
| You filter on a field only in... | [
0.038338903337717056,
-0.05020424723625183,
-0.07202588766813278,
-0.02386671118438244,
0.06330414861440659,
-0.042055174708366394,
0.03436148166656494,
0.02884354256093502,
0.06530893594026566,
-0.017388544976711273,
0.04803084582090378,
0.06326941400766373,
0.05341372266411781,
-0.011047... |
426d8cba-5c0f-5666-87db-547fce03f44c | /documentation/tutorials-operations/scaling-and-monitoring-pods/ | Scaling and Monitoring Hybrid Cloud | Prerequisites | documentation | false | Scaling and Monitoring Hybrid Cloud > Prerequisites
- A Qdrant Hybrid Cloud environment with a `QdrantCluster` already running. See the [Hybrid Cloud setup guide](/documentation/hybrid-cloud/hybrid-cloud-setup/) if you don't have one yet.
- The [`qcloud` CLI](/documentation/cloud-cli/), authenticated against your acco... | [
-0.0063528865575790405,
0.017214225605130196,
-0.04234937205910683,
-0.08403212577104568,
0.06670346856117249,
-0.05126683786511421,
0.06123108044266701,
0.044045589864254,
0.05083993822336197,
-0.05775383487343788,
0.016279881820082664,
-0.005569089204072952,
0.0866512805223465,
-0.030625... |
42724636-f0ce-57d6-805b-d722ddfc3d4e | /documentation/manage-data/quantization/ | Quantization | Scalar Quantization | documentation | false | Quantization > Scalar Quantization
*Available as of v1.1.0*
[Scalar quantization](/articles/scalar-quantization/), in the context of vector search engines, is a compression technique that compresses vectors by reducing the number of bits used to represent each vector component.
For instance, Qdrant uses 32-bit float... | [
0.04305898770689964,
-0.029542915523052216,
-0.04755149409174919,
-0.04099150002002716,
0.034443262964487076,
-0.0004769014485646039,
0.05728844925761223,
0.05333417281508446,
0.12833470106124878,
-0.025810647755861282,
0.03944139555096626,
0.020118417218327522,
0.0258964654058218,
-0.0355... |
42c7b66e-8b11-5a10-82e7-8347f4ded1bb | /documentation/embeddings/superlinked/ | Superlinked | documentation | false | Superlinked
The [Superlinked Inference Engine (SIE)](https://superlinked.com/docs) is an open-source server, under the Apache 2.0 license, that runs open embedding models behind one API. One model can return dense, sparse, and multivector (ColBERT) vectors from the same request. The `sie-qdrant` Python package wraps t... | [
0.056102532893419266,
-0.035229261964559555,
-0.03342759236693382,
-0.07187730073928833,
0.04468310624361038,
-0.0255594439804554,
0.10659737139940262,
0.07256855815649033,
0.036371249705553055,
-0.056034401059150696,
0.02529999613761902,
0.021183283999562263,
0.03642125055193901,
-0.05302... | |
42d1a69e-a0a6-5e62-9f0b-0b61be3709f5 | /documentation/search/search-relevance/ | Search Relevance | Score Boosting | documentation | true | Search Relevance > Score Boosting
_Available as of v1.14.0_
When introducing vector search to specific applications, sometimes business logic needs to be considered for ranking the final list of results.
A quick example is [our own documentation search bar](https://github.com/qdrant/page-search).
It has vectors for ... | [
-0.009628299623727798,
-0.07340262830257416,
-0.03319466859102249,
-0.03400557488203049,
0.0549074150621891,
-0.04270800203084946,
0.027051808312535286,
-0.011028191074728966,
0.046277374029159546,
-0.03636850416660309,
0.003702103625983,
0.053643759340047836,
0.058111771941185,
-0.0190988... |
42d4ab3e-01fe-53b2-b4de-a1cec8cf03f3 | /documentation/tutorials-build-essentials/agentic-rag-langgraph/ | Agentic RAG with LangGraph | Implementation > Qdrant Cloud Setup | documentation | false | Agentic RAG with LangGraph > Implementation > Qdrant Cloud Setup
We'll use **Qdrant Cloud** to store and search document embeddings. Here's how to set it up:
| **Step** | **Description** ... | [
0.02879258617758751,
-0.0484592579305172,
-0.05145437270402908,
-0.021684877574443817,
0.09210184961557388,
-0.061740901321172714,
0.036084286868572235,
0.06501837074756622,
0.04465464875102043,
-0.055237092077732086,
0.013129151426255703,
0.03808927536010742,
0.07811526954174042,
-0.05196... |
42de0e15-1406-5d71-9064-ee74bc9621a4 | /documentation/tutorials-operations/embedding-model-migration/ | Migrate to a New Embedding Model | Migrate Using Named Vectors > Step 2: Enable Dual Writes | documentation | true | Migrate to a New Embedding Model > Migrate Using Named Vectors > Step 2: Enable Dual Writes
Update your upsert service to embed each document with both models and write both named vectors on every upsert:
```python
client.upsert(
collection_name=COLLECTION,
points=[
models.PointStruct(
id=... | [
0.030592894181609154,
-0.05342908203601837,
-0.043504633009433746,
-0.008708338253200054,
0.03317350521683693,
-0.02828650362789631,
0.05650905519723892,
0.058585457503795624,
0.018853798508644104,
0.0028289034962654114,
0.009612077847123146,
0.02351674623787403,
0.05293954163789749,
-0.03... |
42e6717e-8f63-5e32-8ca7-4acba3acc850 | /documentation/faq/database-optimization/ | Database Optimization | How do you choose the machine configuration? | documentation | false | Database Optimization > How do you choose the machine configuration?
There are two main scenarios of Qdrant usage in terms of resource consumption:
- **Performance-optimized** -- when you need to serve vector search as fast (many) as possible. In this case, you need to have as much vector data in RAM as possible. Use... | [
0.029159756377339363,
-0.053430113941431046,
-0.05800148472189903,
-0.026131652295589447,
0.05832512304186821,
-0.039094217121601105,
0.056325118988752365,
-0.001733659766614437,
0.08981626480817795,
-0.01371533889323473,
0.00995564740151167,
-0.030410805717110634,
0.06061374768614769,
-0.... |
42f82cb9-0e90-519b-9086-bdac311520cf | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-5/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product | The Problem We're Solving | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product > The Problem We're Solving
The [series repo](https://github.com/qdrant-labs/finetune-ecommerce-search) is research code. It demonstrates how sparse embedding fine-tuning works. Actually using it on your data means you need to:
1. ... | [
0.0503467358648777,
-0.08278781175613403,
-0.04080936685204506,
-0.028014585375785828,
0.05041007325053215,
-0.006579814478754997,
0.08104705810546875,
0.06473024934530258,
0.06630803644657135,
-0.014341053552925587,
0.014543140307068825,
-0.000872763164807111,
0.050349682569503784,
-0.045... |
43041712-c952-5216-8581-87440ad62a67 | /documentation/scaling/resilience/ | Resilience | Failover Best Practices | documentation | false | Resilience > Failover Best Practices
How Qdrant responds to a node failure depends entirely on how the cluster is provisioned beforehand:
- **Run at least three nodes with a replication factor of two or more in production.** A single-replica cluster, which is the default, gets none of Qdrant's high-availability guara... | [
0.04220493137836456,
-0.025599921122193336,
-0.06182227283716202,
-0.042347993701696396,
0.0804663598537445,
-0.012750492431223392,
0.04107610881328583,
-0.007351079024374485,
0.03815211355686188,
-0.02945001982152462,
0.04324718564748764,
0.015586859546601772,
0.04675258323550224,
-0.0289... |
43222823-3061-54f8-8385-d4e1cbc7b202 | /course/multi-vector-search/module-3/muvera/ | MUVERA | Applying MUVERA Multi-Stage Retrieval > Trade-offs and Considerations | course | false | MUVERA > Applying MUVERA Multi-Stage Retrieval > Trade-offs and Considerations
**Storage Requirements**: MUVERA requires storing both representations - the single approximation vector and the full multi-vector sequence. This doubles storage compared to single-vector search, but remains practical for production systems... | [
0.011003440245985985,
-0.06520365178585052,
-0.04579579085111618,
-0.048894722014665604,
0.03735191747546196,
-0.023927628993988037,
0.028090620413422585,
0.00018773919146042317,
0.08089633285999298,
-0.004488104488700628,
-0.01746116578578949,
0.03835960105061531,
0.06387564539909363,
-0.... |
43332459-fcfb-52a5-b107-2ed88215bbd3 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > GPU | documentation | false | API Reference > qdrant.io/v1 > Resource Types > GPU
_Appears in:_
- [QdrantClusterSpec](#qdrantclusterspec)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `gpuType` _[GPUType](#gputype)_ | GPUType specifies the type of the GPU to use. If set, GPU indexing is enabled. | | Enum: [nvidia amd... | [
0.03725473955273628,
-0.048739053308963776,
-0.06196434050798416,
-0.017533766105771065,
0.07353394478559494,
-0.024794870987534523,
0.04335113987326622,
0.08490709215402603,
0.08865385502576828,
-0.031725067645311356,
0.045763418078422546,
0.04040027782320976,
0.032277993857860565,
-0.033... |
43479a65-e4f9-5716-9aae-91759475d50d | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-4/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization
*This is Part 4 of a 5-part tutorial on fine-tuning sparse embeddings for e-commerce search. In [Part 3](/documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-3/), we evaluated our model and implemente... | [
0.04997715353965759,
-0.04336507245898247,
-0.06866294145584106,
-0.03628341481089592,
0.05152804031968117,
-0.033007699996232986,
0.06895996630191803,
0.011668086051940918,
0.06378662586212158,
-0.0011585665633901954,
0.016845379024744034,
0.019417189061641693,
0.0575726144015789,
-0.0468... | |
4348c0eb-8598-5fb3-b448-9fb0c835ac60 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-5/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product | Getting Started | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product > Getting Started
You need Python 3.10 or later, a [Modal](https://modal.com/) account with a payment method on file, a Qdrant URL (and API key for Qdrant Cloud), an API key for your LLM provider if you generate synthetic queries, a... | [
0.05714626982808113,
-0.08287213742733002,
-0.016550548374652863,
-0.02492203749716282,
0.041507937014102936,
0.0026429591234773397,
0.06823354959487915,
0.03862396255135536,
0.07576281577348709,
-0.03654550015926361,
0.017734646797180176,
0.014598086476325989,
0.054059918969869614,
-0.034... |
43609184-1628-5371-8d3d-276e2c164eb0 | /course/essentials/day-6/final-project/ | Final Project: Production-Ready Documentation Search Engine | Build Steps > Step 7: Analyze Your Results | course | true | Final Project: Production-Ready Documentation Search Engine > Build Steps > Step 7: Analyze Your Results
Build a small eval set and measure quality and latency. Use results to guide tuning (fusion strategy, candidate sizes, search-time `hnsw_ef`, etc.).
**Ground Truth**:
- Create 20–30 realistic queries with expected... | [
0.003510145004838705,
-0.06661687791347504,
-0.05293198302388191,
-0.007140700239688158,
0.05672276392579079,
-0.014244801364839077,
0.05762165039777756,
0.012465239502489567,
0.0892459899187088,
-0.056907251477241516,
0.037355005741119385,
-0.010248028673231602,
0.07432622462511063,
-0.02... |
4361c24d-fd5d-5b21-ad79-988a74ae8ab8 | /documentation/migrate-to-qdrant/from-mongodb/ | From MongoDB | What You Need from MongoDB | documentation | false | From MongoDB > What You Need from MongoDB
- **Connection string** — MongoDB URI (e.g., `mongodb://user:pass@host:27017`)
- **Database name** — the database containing your collection
- **Collection name** — the collection to migrate
- **Vector field names** — the names of fields that store vector embeddings
Important... | [
0.0406915619969368,
-0.06406189501285553,
-0.04524317756295204,
-0.022243650630116463,
0.057303231209516525,
-0.044129811227321625,
0.06897091865539551,
0.06374942511320114,
0.06185518577694893,
-0.042701900005340576,
0.039144210517406464,
-0.02275579236447811,
0.036962199956178665,
-0.018... |
437b0f4f-17c3-5753-9af9-db377cf8d200 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > QdrantConfigurationCollectionVectors | documentation | false | API Reference > qdrant.io/v1 > Resource Types > QdrantConfigurationCollectionVectors
_Appears in:_
- [QdrantConfigurationCollection](#qdrantconfigurationcollection)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `on_disk` _boolean_ | OnDisk specifies whether vectors should be stored in mem... | [
0.05172860994935036,
-0.060710616409778595,
-0.014613344334065914,
-0.07046052068471909,
0.05891362950205803,
-0.03399474546313286,
0.042220547795295715,
0.0779830813407898,
0.07051140069961548,
-0.04885619506239891,
0.0011339420452713966,
0.012460190802812576,
0.07081959396600723,
-0.0282... |
43840530-c563-525f-8597-ac5f396ccaa4 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-3/ | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment | Streaming Backpressure | documentation | false | Video Anomaly Detection Part 3: Scoring, Governance, and Deployment > Streaming Backpressure
In production, the cloud tier must handle bursts of escalations from multiple edge devices. The streaming pipeline implements adaptive degradation:
| Queue Utilization | Mode | Behavior |
|------------------|------|----------... | [
0.044828228652477264,
-0.0204887967556715,
-0.05847204104065895,
-0.030871611088514328,
0.025863854214549065,
-0.008379972539842129,
0.07333949953317642,
0.04824582114815712,
0.05025371536612511,
-0.012707395479083061,
0.03695548325777054,
0.032586872577667236,
0.018367059528827667,
-0.046... |
439444f2-c84e-5a19-88f8-ad8addc56574 | /documentation/tutorials-build-essentials/video-anomaly-edge-part-2/ | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline | Mutable Shard Retention > Option C: Score-Priority Eviction (score_priority) | documentation | true | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline > Mutable Shard Retention > Option C: Score-Priority Eviction (score_priority)
```env
RETENTION_STRATEGY=score_priority
RETENTION_MAX_POINTS=2000
```
Caps the mutable shard at `RETENTION_MAX_POINTS`. Unsynced points with anomaly scores above the escalation thresh... | [
0.037467509508132935,
-0.03283940628170967,
-0.05689416825771332,
-0.0440506786108017,
0.01856725476682186,
-0.03561810404062271,
0.055758919566869736,
-0.011008009314537048,
0.09187682718038559,
-0.05237959325313568,
0.019734002649784088,
0.0378120094537735,
0.050227824598550797,
-0.01647... |
43b2e91f-8b77-58bd-9a42-29a7dc4040ce | /course/essentials/day-3/pitstop-project/ | Project: Building a Hybrid Search Engine | course | false | Project: Building a Hybrid Search Engine
Day 3
Build a hybrid system that combines dense and sparse vectors with Reciprocal Rank Fusion, demonstrating how to get the best of both semantic understanding and keyword precision. | [
0.0130817461758852,
-0.009340950287878513,
-0.06824581325054169,
-0.05757152661681175,
0.08854389190673828,
-0.05857880786061287,
0.0855618342757225,
0.025158580392599106,
0.05925352871417999,
-0.03154323622584343,
0.015554719604551792,
0.024795038625597954,
0.08520786464214325,
-0.0240564... | |
43cae529-b2de-5057-98bf-def5f2617f04 | /documentation/security/ | Security | documentation | false | Security
Securing a Qdrant deployment means controlling who can access your data, encrypting traffic, and keeping an audit trail for compliance. To secure your deployments, Qdrant supports [API key authentication](#authentication) (including [read-only API keys](#read-only-api-key) for query-only consumers and [granul... | [
0.02417033724486828,
-0.06058191508054733,
-0.036468904465436935,
-0.050958555191755295,
0.03874458000063896,
-0.03871109336614609,
0.08816318958997726,
0.029187504202127457,
0.054259855300188065,
-0.02003994770348072,
0.020088521763682365,
-0.01996798813343048,
0.07325604557991028,
-0.041... | |
43e0cc1c-fd29-52f3-820d-4831f52acb91 | /documentation/migrate-to-qdrant/from-azure-search/ | From Azure AI Search | What You Need from Azure AI Search | documentation | false | From Azure AI Search > What You Need from Azure AI Search
- **Service endpoint** — e.g. `https://your-service.search.windows.net`
- **Index name** — the index containing your vectors
- **Admin API key** — used to authenticate with the Azure AI Search REST API | [
0.023141400888562202,
-0.04846782982349396,
-0.054155249148607254,
-0.03623746708035469,
0.04461215063929558,
-0.020323045551776886,
0.02433888241648674,
0.024543391540646553,
0.04599510505795479,
-0.026877203956246376,
0.04482385143637657,
0.04128830507397652,
0.05981761962175369,
-0.0411... |
43e96f53-2168-5ad9-800d-448146dcd25a | /documentation/fastembed/fastembed-minicoil/ | Working with miniCOIL | Create Collection | documentation | true | Working with miniCOIL > Create Collection
Let's create a collection to store and index titles.
As miniCOIL was designed with Qdrant's ability to calculate the keywords Inverse Document Frequency (IDF) in mind, we need to configure miniCOIL sparse vectors with [IDF modifier](/documentation/manage-data/indexing/#idf-mo... | [
0.05484871566295624,
-0.031403522938489914,
0.006042120512574911,
-0.033956676721572876,
0.05226382613182068,
-0.05767400562763214,
0.09166520088911057,
0.06202206015586853,
0.05106305330991745,
-0.04283720999956131,
0.0036317333579063416,
0.00560265826061368,
0.04087764024734497,
-0.01359... |
43eb4c6a-2666-526c-b64f-7e642377d80b | /documentation/migration-guidance/search-quality/ | Search Quality | Tier 3: Gold-Standard Evaluation (When You Have Labeled Data) > Why Tier 3 Matters | documentation | false | Search Quality > Tier 3: Gold-Standard Evaluation (When You Have Labeled Data) > Why Tier 3 Matters
Tier 2 assumes the source system's results are the ground truth. But if you're migrating because your source system's search quality was insufficient, matching its results perfectly is the wrong goal. Tier 3 measures ag... | [
0.02792065031826496,
-0.05513416603207588,
-0.05696706846356392,
-0.025947583839297295,
0.05036370828747749,
0.00470336340367794,
0.08177486807107925,
0.03648507595062256,
0.0832892581820488,
-0.020725103095173836,
0.015308944508433342,
-0.022397419437766075,
0.06288997828960419,
-0.013333... |
443f949a-090d-54b7-9e22-75b4e76210d8 | /documentation/frameworks/langchain/ | LangChain | Local mode | documentation | true | LangChain > Local mode
Python client allows you to run the same code in local mode without running the Qdrant server. That's great for testing things
out and debugging or if you plan to store just a small amount of vectors. The embeddings might be fully kept in memory or
persisted on disk.
### In-memory
For some tes... | [
0.044374655932188034,
-0.06161564961075783,
-0.015194812789559364,
-0.004812890663743019,
0.04104926437139511,
-0.03796522319316864,
0.06320080161094666,
0.014743282459676266,
0.08301961421966553,
-0.009966183453798294,
-0.0013585047563537955,
0.0174648966640234,
0.03237668052315712,
-0.02... |
4445cedd-f222-5bed-ab49-e5f02ccc5f63 | /documentation/migration-guidance/diagnosing-discrepancies/ | Diagnosing Discrepancies | Configuration-Level Issues > HNSW Index Not Built | documentation | true | Diagnosing Discrepancies > Configuration-Level Issues > HNSW Index Not Built
On a freshly migrated collection, the HNSW index may still be building. During this period, Qdrant falls back to brute-force search, which returns exact results (recall = 1.0). Once the index finishes building, results shift to approximate.
... | [
0.02950263023376465,
-0.0385502353310585,
-0.03479927405714989,
-0.030200418084859848,
0.05563850328326225,
-0.040430374443531036,
0.054376259446144104,
0.05009721592068672,
0.07391390949487686,
-0.04691866412758827,
0.0320141538977623,
0.04287337511777878,
0.043370917439460754,
-0.0205305... |
44699b3f-0458-5e85-88ad-ca493aeeb709 | /articles/filterable-hnsw/ | Filterable HNSW Without Recall Loss | How can we modify it? | article | false | Filterable HNSW Without Recall Loss > How can we modify it?
In the first case, we can guarantee that the HNSW graph will be connected simply by creating additional edges
inside each category separately, using the same graph construction algorithm, and then combining them into the original graph.
In this case, the tota... | [
0.058038339018821716,
-0.04520377516746521,
-0.05325603857636452,
-0.02069094590842724,
0.060641974210739136,
-0.016992833465337753,
0.0639989897608757,
0.03443755581974983,
0.05077681317925453,
-0.028146518394351006,
0.04237014800310135,
0.036185912787914276,
0.0803615152835846,
0.0159997... |
4477c0be-1e7c-57f6-9d3b-ae63fa08d4d0 | /documentation/support/ | Support | Qdrant Cloud Support | documentation | false | Support > Qdrant Cloud Support
## Community Support
All Qdrant Cloud users are welcome to join our [Discord community](https://qdrant.to/discord/).

Paying customers have access to our Support team. Links to the support portal are available in the Qdrant Cloud Console.
!... | [
0.03423738479614258,
-0.0017191608203575015,
-0.03839794546365738,
-0.018814342096447945,
0.007221575360745192,
-0.02381385676562786,
0.05336470529437065,
0.04115521162748337,
0.07119111716747284,
-0.025346368551254272,
0.04199109226465225,
-0.02429819665849209,
0.03391076251864433,
-0.027... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.