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 |
|---|---|---|---|---|---|---|---|
79db60dd-37ac-5e39-a890-0b2005ff143c | /course/beginners/module-0/qdrant-cloud/ | Qdrant Setup | Qdrant Agent Skills | course | true | Qdrant Setup > Qdrant Agent Skills
If you're using an AI coding assistant (Claude Code, Cursor, and others) alongside this course, install the [Qdrant Advisor skill](https://qdrant.tech/documentation/skills/#the-qdrant-advisor) early with this simple command:
```bash
npx skills add qdrant/skills/meta/qdrant-advisor
`... | [
0.03465157747268677,
-0.04171392694115639,
-0.054849255830049515,
-0.04992830008268356,
0.05855473503470421,
-0.05441144481301308,
0.040066733956336975,
0.026551716029644012,
0.058629948645830154,
-0.03226306661963463,
0.06220396235585213,
-0.004349248483777046,
0.04935626685619354,
-0.030... |
79db8f8a-d382-5c41-9aeb-ed5d396425cf | /course/beginners/module-3/the-two-families-of-search/ | The Two Families of Search | Sparse Search | course | true | The Two Families of Search > Sparse Search

Sparse vectors are token-based: each dimension corresponds to a token, only the tokens present carry a weight, and everything else is zero. Storing that mos... | [
0.0635816901922226,
-0.017471784725785255,
-0.05496670678257942,
-0.057819634675979614,
0.07047518342733383,
-0.03470546752214432,
0.03375682234764099,
0.011807948350906372,
0.06676807254552841,
-0.029667813330888748,
0.048543594777584076,
0.0355590395629406,
0.04761964827775955,
-0.003124... |
79ed583b-f470-5591-95a7-943248bc5603 | /documentation/ops-monitoring/slow-request-log/ | Slow Request Log | Reading the Log | documentation | true | Slow Request Log > Reading the Log
`GET /profiler/slow_requests` returns the current state of the log. The endpoint requires `manage` access and is available as a REST API only.
**Query parameters:**
| Parameter | Default | Description |
|-----------|---------|-------------|
| `limit` | 10 | Maximum number of entrie... | [
-0.0071407645009458065,
-0.05106758698821068,
-0.041174568235874176,
-0.052949562668800354,
0.025658588856458664,
-0.021708620712161064,
0.044959358870983124,
0.04837067425251007,
0.07503718137741089,
0.004824817646294832,
0.013853983022272587,
0.06967136263847351,
0.035028956830501556,
-0... |
7a230f70-59cc-5e89-8220-d40b27b1ecea | /documentation/search/filtering/ | Filtering | Filtering Conditions > Exact Match Conditions > Prefix Match | documentation | true | Filtering > Filtering Conditions > Exact Match Conditions > Prefix Match
*Available as of v1.19.0*
A match `prefix` condition matches [keyword](/documentation/manage-data/payload/#keyword) values that start with the specified string.
For example, the prefix `"https://qdrant."` matches the value `"https://qdrant.tech... | [
0.03687439113855362,
-0.048799291253089905,
-0.05419688671827316,
-0.015741510316729546,
0.051438745111227036,
-0.04848182573914528,
0.054244570434093475,
0.014840401709079742,
0.07786154747009277,
-0.0238092839717865,
0.012305953539907932,
0.024311764165759087,
0.05805503576993942,
-0.029... |
7a2f8431-ae17-50b3-a420-2635f6930f4d | /documentation/tutorials-basics/reranking-hybrid-search/ | Hybrid Search with Reranking | documentation | false | Hybrid Search with Reranking
| Time: 40 min | Level: Intermediate |
| --- | ----------- |
Reranking is a powerful technique for improving search precision: rather than running an expensive model over your entire corpus, you apply it to a smaller set of candidates already retrieved by a faster method. This keeps laten... | [
0.03743099421262741,
-0.014046818017959595,
-0.060337264090776443,
-0.07293255627155304,
0.0817173644900322,
-0.056380510330200195,
0.08003182709217072,
0.04997318983078003,
0.09923255443572998,
-0.01102733425796032,
0.029979852959513664,
0.014629648067057133,
0.039784643799066544,
-0.0393... | |
7a5e3d37-2709-5149-b6d2-a0fe534574d2 | /documentation/platforms/apify/ | Apify | documentation | true | Apify
[Apify](https://apify.com/) is a web scraping and browser automation platform featuring an [app store](https://apify.com/store) with over 1,500 pre-built micro-apps known as Actors. These serverless cloud programs, which are essentially dockers under the hood, are designed for various web automation applications... | [
0.031518951058387756,
-0.027738159522414207,
-0.021307848393917084,
-0.050873253494501114,
0.06476440280675888,
-0.02057848684489727,
0.04095189645886421,
0.020778469741344452,
0.03122350387275219,
-0.036984607577323914,
0.025351472198963165,
0.039275337010622025,
0.06254297494888306,
-0.0... | |
7a65cfbe-9a68-599c-a09e-630803037df9 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 3. What's the Best Way to Scale the Database and Optimize Resources? > Dealing With Imbalanced or Overworked Nodes | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 3. What's the Best Way to Scale the Database and Optimize Resources? > Dealing With Imbalanced or Overworked Nodes
||
|:-:|
|**"One of my nodes is doing way more work than the others."**|
**Use Case:** A SaaS platform added hundreds of new customers. Suddenly,... | [
0.030884502455592155,
-0.038373105227947235,
-0.07975123822689056,
-0.013523124158382416,
0.046774543821811676,
-0.04307034611701965,
0.04258762300014496,
0.016314717009663582,
0.08210691064596176,
-0.015452699735760689,
0.01801915653049946,
0.011328515596687794,
0.03475501015782356,
-0.05... |
7a67bc77-4f68-5956-a748-1f6dd164d7ad | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | Key Takeaways | course | false | HNSW Indexing Fundamentals > Key Takeaways
1. **HNSW**: reduces O(N) scans to roughly O(log N) graph search
2. **`m`**: controls graph density - more connections improve accuracy but use more memory
3. **`ef_construct`**: affects graph quality - higher values create more granular graphs but take longer to build
4. **`... | [
0.02081894315779209,
-0.044216640293598175,
-0.06630611419677734,
-0.0076629710383713245,
0.019543074071407318,
-0.01974727399647236,
0.04529993608593941,
0.0553576834499836,
0.06823204457759857,
-0.022165315225720406,
0.03356517478823662,
0.035305000841617584,
0.06228763982653618,
0.00473... |
7a6edce8-8005-59d1-816e-ad734126e1e3 | /course/multi-vector-search/module-3/pooling-techniques/ | Pooling Techniques | Pooling for Multi-Vector Representations > Generic Methods | course | false | Pooling Techniques > Pooling for Multi-Vector Representations > Generic Methods
While row/column pooling exploits the spatial structure of image embeddings, **hierarchical token pooling** works for any multi-vector representation - text, images, or hybrid documents. The core idea: instead of grouping by fixed spatial ... | [
0.04339176043868065,
-0.02989526465535164,
-0.06766097247600555,
-0.035826582461595535,
0.06811506301164627,
-0.023744583129882812,
0.05648733675479889,
0.0524507537484169,
0.08395742624998093,
-0.0179354976862669,
0.03630521520972252,
-0.0018274224130436778,
0.045547183603048325,
-0.00725... |
7a7ae4f5-b22f-5431-900a-ea65e0049dc4 | /course/essentials/day-7/haystack/ | Integrating with Haystack | Resources | course | false | Integrating with Haystack > Resources
- [Haystack Qdrant Integration](https://haystack.deepset.ai/integrations/qdrant-document-store):
Official Haystack documentation for using Qdrant as a document store. Learn about installation, usage, and connecting to Qdrant Cloud clusters.
- [Qdrant & Haystack Integration Gu... | [
0.04366742819547653,
-0.03550473600625992,
-0.07720551639795303,
-0.03341895341873169,
0.055800653994083405,
-0.04425221309065819,
0.03806960955262184,
0.03416776657104492,
0.051907166838645935,
-0.02259540744125843,
0.016181660816073418,
-0.016260983422398567,
0.03390314057469368,
-0.0408... |
7a7df402-b709-520b-b305-3af383385c53 | /course/multi-vector-search/module-3/muvera/ | MUVERA | The HNSW Incompatibility Problem | course | false | MUVERA > The HNSW Incompatibility Problem
Traditional vector indexes like HNSW are designed for single-vector search with symmetric distance metrics. Multi-vector representations break this assumption: **MaxSim is inherently asymmetric and non-metric**.
When comparing query tokens to document tokens, the direction ma... | [
0.06051607429981232,
-0.03523026034235954,
-0.052529267966747284,
-0.026786847040057182,
0.06269221007823944,
-0.03650014102458954,
0.07277516275644302,
0.0201557669788599,
0.03188181295990944,
0.022693028673529625,
0.033483415842056274,
0.05055808275938034,
0.06612249463796616,
-0.0116143... |
7a802d12-c71b-58ea-8fd2-eb0498f7d17a | /documentation/manage-data/indexing/ | Indexing | Vector Index > Filterable HNSW Index | documentation | false | Indexing > Vector Index > Filterable HNSW Index
Separately, a payload index and a vector index cannot completely address the challenges of filtered search.
In the case of high-selectivity (weak) filters, you can use the HNSW index as it is.
In the case of low-selectivity (strict) filters, you can use the payload inde... | [
0.028666842728853226,
-0.03291674703359604,
-0.04264293611049652,
-0.016536477953195572,
0.06031853333115578,
-0.05205225944519043,
0.06056707724928856,
0.027416124939918518,
0.05473943054676056,
-0.03099861554801464,
0.05697326362133026,
0.0711335763335228,
0.043384429067373276,
-0.012833... |
7aa97876-072a-59ed-94fb-2768862400bd | /documentation/data-management/poma/ | POMA | 1. Get API Keys | documentation | true | POMA > 1. Get API Keys
### POMA API key
1. Open https://app.poma-ai.com/
2. Register or sign in.
3. Open **API Keys** in the left navigation.
4. Copy your key and export it as `POMA_API_KEY`.
### Qdrant cluster API key
During Qdrant cluster creation, or when creating fine-grained API keys, see further details [here... | [
0.05468633025884628,
-0.06744556128978729,
-0.0114727932959795,
-0.0703299343585968,
0.07390522956848145,
-0.05650350823998451,
0.04176023602485657,
0.0586424246430397,
0.06237522140145302,
-0.029202530160546303,
0.017523033544421196,
0.0057457066141068935,
0.0596865676343441,
-0.043378710... |
7ad1e3b5-9737-5ecf-823c-b10386eee80c | /documentation/scaling/distributed_deployment/ | Distributed Deployment | Sharding > User-Defined Sharding > Multitenancy | documentation | true | Distributed Deployment > Sharding > User-Defined Sharding > Multitenancy
A use-case for this feature is managing a multi-tenant collection, where each tenant (let it be a user or organization) is assumed to be segregated, so they can have their data stored in separate shards. See [User-defined sharding](/documentation... | [
0.02289598621428013,
-0.01602802984416485,
-0.07340028882026672,
-0.0065314085222780704,
0.04369223117828369,
-0.043205998837947845,
0.032006483525037766,
0.046833138912916183,
0.08088742196559906,
-0.0058763474225997925,
0.015522265806794167,
0.024156635627150536,
0.051304981112480164,
-0... |
7ad74cc0-a172-5a11-9a37-e947c1417e8a | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Vector Search Optimization > Tools of a Vector Search Engine > ...Should Be Universal | article | false | Relevance Feedback in Qdrant > Vector Search Optimization > Tools of a Vector Search Engine > ...Should Be Universal
**For every type of data**
Vector search is attractive because it is agnostic to the data type: images, video, audio, molecules… Not only text. Vector search native tools should be the same, operating... | [
0.0366404764354229,
-0.05861278995871544,
-0.07592903822660446,
-0.040518052875995636,
0.050425492227077484,
-0.029597336426377296,
0.05365157499909401,
-0.002195974113419652,
0.051836103200912476,
0.004840407520532608,
0.04226672276854515,
0.05022032931447029,
0.10735970735549927,
-0.0355... |
7af59bff-f71a-5bb0-8936-0ed71947deda | /documentation/tutorials-search-engineering/using-multivector-representations/ | Multivectors and Late Interaction | 1. Encode Documents | documentation | true | Multivectors and Late Interaction > 1. Encode Documents
Next, encode your documents:
```python
# With qdrant-client[fastembed] installed, models.Document values below are embedded locally by FastEmbed
# Example documents and query
documents = [
"Artificial intelligence is used in hospitals for cancer diagnosis an... | [
0.03396087884902954,
-0.04905373975634575,
-0.057879235595464706,
-0.054346371442079544,
0.05506898835301399,
-0.04141964390873909,
0.04767308384180069,
0.04942452162504196,
0.08321921527385712,
-0.035572316497564316,
0.0162455253303051,
0.03915739804506302,
0.06659810990095139,
-0.0218091... |
7b16c0e1-cee4-5a53-8899-f77b825ae4cb | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Sparse Neural Retrieval with SPLADE++ & Qdrant | course | true | Demo: Keyword Search with Sparse Vectors > Sparse Neural Retrieval > SPLADE: Sparse Lexical and Expansion Model > Sparse Neural Retrieval with SPLADE++ & Qdrant
Let’s now see SPLADE++ in action solving the **vocabulary mismatch** problem.
```python
client.query_points(
collection_name=<COLLECTION_NAME>,
using... | [
0.08329613506793976,
-0.038919221609830856,
-0.04001937061548233,
-0.04677214100956917,
0.08738973736763,
-0.04794500395655632,
0.048640865832567215,
0.020499233156442642,
0.05616870895028114,
-0.02040938474237919,
0.03781907260417938,
-0.007512305397540331,
0.0501847118139267,
-0.02975077... |
7b2b768f-3a18-5d16-9e21-25ddad670507 | /documentation/manage-data/collections/ | Collections | Update Collection > Update Vector Schema | documentation | true | Collections > Update Collection > Update Vector Schema
*Available as of v1.18.0*
Named vectors can be added to or removed from an existing collection without having to recreate the collection. This is useful for [embedding model migration](/documentation/tutorials-operations/embedding-model-migration/): you can add a... | [
0.04648381844162941,
-0.04292796924710274,
-0.02681106887757778,
-0.031257979571819305,
0.03943862393498421,
-0.0215521901845932,
0.020177099853754044,
0.04748043045401573,
0.08163626492023468,
-0.056608669459819794,
0.04007695987820625,
0.0611492320895195,
0.022936945781111717,
-0.0204283... |
7b2caf7f-8db8-54c3-8c04-29f30ff1c3f5 | /documentation/ops-configuration/memory-tiers/ | Memory Tiers | Migrating > Legacy Settings > HNSW Vector Index | documentation | false | Memory Tiers > Migrating > Legacy Settings > HNSW Vector Index
The legacy parameter is `on_disk`, set in `hnsw_config`.
| `memory` | Legacy value |
|---|---|
| `pinned` | No legacy equivalent |
| `cached` | `on_disk: false` |
| `cold` | `on_disk: true` | | [
0.024412378668785095,
-0.054656725376844406,
-0.0033453679643571377,
-0.035412922501564026,
0.03255162760615349,
-0.03005295619368553,
0.03291511908173561,
0.060167595744132996,
0.03646117076277733,
-0.028311556205153465,
0.003857866395264864,
0.03593378886580467,
0.05348857492208481,
-0.0... |
7b464c42-5e04-50d3-bc7c-e9efad139bb5 | /articles/what-is-a-vector-database/ | What is a Vector Database? | The Architecture of a Vector Database | article | false | What is a Vector Database? > The Architecture of a Vector Database
> A quick note on naming. You'll almost always hear these systems called vector databases, but the term is a little misleading. Traditional databases like Postgres or MySQL are built on ACID principles: transactions, strong consistency, and atomicity. ... | [
-0.008919412270188332,
-0.0404929518699646,
-0.07223844528198242,
-0.04005018621683121,
0.03371253237128258,
-0.03532414883375168,
0.06667973846197128,
0.029195178300142288,
0.07401024550199509,
-0.028225794434547424,
0.04571029916405678,
0.038204632699489594,
0.05697530135512352,
-0.00985... |
7b4ca724-7a4f-5b59-a919-6c70318ad34b | /documentation/embeddings/superlinked/ | Superlinked | Next Steps | documentation | false | Superlinked > Next Steps
- [Learn how hybrid queries work](/documentation/search/hybrid-queries/), including other fusion methods.
- [Configure multivectors](/documentation/manage-data/vectors/#multivectors) for ColBERT and other late-interaction models.
- Read the [SIE Qdrant integration guide](https://superlinked.co... | [
0.05072338134050369,
-0.016829662024974823,
-0.05016619712114334,
-0.03808162733912468,
0.050708845257759094,
-0.028969446197152138,
0.05047512799501419,
0.03340321406722069,
0.06557363271713257,
-0.021923063322901726,
0.04220850020647049,
0.005563606973737478,
0.041374556720256805,
-0.029... |
7b4d766f-c125-532a-be6e-9c3f083fb797 | /documentation/search-precision/automate-filtering-with-llms/ | LLM-Powered Filter Automation | Using Instructor to generate Qdrant filters > Handling complex queries | documentation | true | LLM-Powered Filter Automation > Using Instructor to generate Qdrant filters > Handling complex queries
We have a bunch of indexes created on the collection, and it is quite interesting to see how the LLM will handle more
complex queries. For example, let's see how it will handle the following query:
```python
qdrant_... | [
0.04578881710767746,
-0.018077148124575615,
-0.04105151817202568,
-0.037600740790367126,
0.06187216192483902,
-0.030849386006593704,
0.06282707303762436,
0.04556265473365784,
0.05084877833724022,
-0.018034180626273155,
0.030029457062482834,
0.010002913884818554,
0.07833406329154968,
-0.027... |
7b8a7749-b315-585f-8501-eb2e769f9b4f | /course/essentials/day-7/unstructured/ | Integrating with Unstructured.io | Unstructured Enterprise Data Processing > Core Architecture | course | false | Integrating with Unstructured.io > Unstructured Enterprise Data Processing > Core Architecture
Unstructured.io's enterprise-grade platform offers several key components:
- **VLM Partitioner**: Uses GPT-4o vision for intelligent document understanding, recognizing layout, tables, images, and text hierarchy
- **Smart C... | [
0.003028630977496505,
-0.02068328484892845,
-0.07048559933900833,
-0.02025766298174858,
0.0664534866809845,
-0.018284067511558533,
0.06660202145576477,
0.026445919647812843,
0.030597815290093422,
-0.013694033958017826,
0.02715807780623436,
-0.0198620967566967,
0.07252823561429977,
-0.02965... |
7b97f8e4-c77b-520f-baf5-415a37597881 | /documentation/production-operations/access-control/ | Data Privacy with Qdrant's Role-Based Access Control (RBAC) | How Qdrant Handles Data Privacy and Security > Cloud RBAC | documentation | false | Data Privacy with Qdrant's Role-Based Access Control (RBAC) > How Qdrant Handles Data Privacy and Security > Cloud RBAC
[Cloud RBAC](https://qdrant.tech/documentation/cloud-rbac/) governs what a user can do inside the Qdrant cloud console and account: managing clusters, billing, identity and access management, Hybrid ... | [
0.038403138518333435,
-0.0032089168671518564,
-0.04933873564004898,
-0.020489146932959557,
0.04989087954163551,
-0.0367463193833828,
0.04582798480987549,
0.06353898346424103,
0.07130833715200424,
-0.04385219141840935,
0.007383843883872032,
0.021650340408086777,
0.08143653720617294,
-0.0134... |
7bad27f7-08e3-5887-ba97-300790d03f73 | /documentation/cloud/cluster-scaling/ | Scale Clusters | Vertical Scaling > Scaling Down Disk Space | documentation | false | Scale Clusters > Vertical Scaling > Scaling Down Disk Space
You can reduce the disk size of your cluster nodes as well as increase it. Cloud providers don't support shrinking a disk in place, so Qdrant Cloud replaces the nodes instead. For each node, Qdrant Cloud:
1. Creates a new node with the smaller disk.
2. Repli... | [
0.03332465887069702,
-0.01421214360743761,
-0.031663186848163605,
-0.04727238044142723,
0.0962577611207962,
-0.004335138481110334,
0.047010041773319244,
0.03057992085814476,
0.08607049286365509,
-0.050218209624290466,
0.01292477361857891,
-0.013259644620120525,
0.050547368824481964,
-0.010... |
7bb9cd6e-1c29-5216-bf10-214abbec0807 | /documentation/tutorials-search-engineering/multi-representation-search/ | Multi-Representation Search | Dataset | documentation | true | Multi-Representation Search > Dataset
You'll work with 20 000 ML/CS arXiv papers (2018 and later) from the [`gfissore/arxiv-abstracts-2021`](https://huggingface.co/datasets/gfissore/arxiv-abstracts-2021) dataset. Each paper has a title, an abstract, and category tags, giving you three text representations once the abs... | [
0.024827441200613976,
0.006283552385866642,
-0.080001600086689,
-0.04244662821292877,
0.06038841977715492,
-0.05019238218665123,
0.03428913280367851,
0.04443871229887009,
0.022443758323788643,
-0.02151591330766678,
0.03732026740908623,
0.03571639582514763,
0.0742206871509552,
-0.0338182523... |
7bba296f-62ad-5662-88dc-77147392e0c7 | /articles/turboquant-quantization/ | TurboQuant in Qdrant | What Is TurboQuant? > MSE vs PROD: Picking the Variant | article | false | TurboQuant in Qdrant > What Is TurboQuant? > MSE vs PROD: Picking the Variant
The original paper proposes two variants. **MSE** is the literal recipe above: scalar Lloyd-Max quantization, score by codebook lookup. **PROD** adds a second QJL random projection on top of the indices to cancel the per-vector length bias t... | [
0.03495769575238228,
-0.03037458285689354,
-0.05324392765760422,
-0.021757692098617554,
0.037535205483436584,
-0.010182371363043785,
0.048669904470443726,
0.012140840291976929,
0.08164044469594955,
-0.025223933160305023,
0.032602459192276,
0.010088942013680935,
0.07035952806472778,
-0.0105... |
7bc9792a-f132-5817-85e1-266134155a01 | /documentation/production-operations/bulk-data-import/ | Bulk Uploading Data to Qdrant | Throughput Choices > Parallelize Uploads | documentation | true | Bulk Uploading Data to Qdrant > Throughput Choices > Parallelize Uploads
_Dense & sparse vectors_
A single upload stream may not keep Qdrant's write path busy. Two to four workers, each sending its own stream of batches, can raise throughput, especially when the collection has multiple shards.
![A single upload work... | [
0.03371146693825722,
-0.03918316215276718,
-0.028015784919261932,
-0.030046304687857628,
0.09537393599748611,
-0.03647745028138161,
0.06384187191724777,
0.019593341276049614,
0.06431244313716888,
-0.03666366636753082,
0.011477812193334103,
0.03553669527173042,
0.02267111837863922,
-0.02205... |
7bd794da-6587-5409-9467-c0864e0017ef | /documentation/tutorials-build-essentials/video-anomaly-edge-part-2/ | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline | Two-Shard Edge Architecture | documentation | false | Video Anomaly Detection Part 2: Edge-to-Cloud Pipeline > Two-Shard Edge Architecture
This is the technical heart of the system. Edge devices need to serve kNN queries with minimal latency while continuously ingesting new clips.
Why can't we just run a single shard on the edge? Two reasons: (1) Building an HNSW index ... | [
-0.006016450468450785,
-0.04213446006178856,
-0.08903656154870987,
-0.048017412424087524,
0.025691766291856766,
-0.03226548060774803,
0.06052886322140694,
0.035221077501773834,
0.062162283807992935,
-0.002208189805969596,
0.0321231409907341,
0.0339333713054657,
0.06370861828327179,
0.00189... |
7bdac5fb-a669-5eb5-8fc3-5c7c456063a9 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-4/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization | Why Generalization Degrades | documentation | false | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 4: Specialization vs Generalization > Why Generalization Degrades
The cross-domain results reveal a fundamental tradeoff. Fine-tuning teaches the model:
- **Amazon-specific query patterns:** short, product-focused queries with brand names and model numbers
- ... | [
0.03354358300566673,
-0.0229960847645998,
-0.06400995701551437,
-0.04277203232049942,
0.02793782204389572,
-0.028140023350715637,
0.0610143207013607,
-0.00576160429045558,
0.06968675553798676,
-0.01777506060898304,
0.012250312604010105,
0.031001072376966476,
0.07181809842586517,
-0.0245429... |
7c04ba83-cb44-50ad-8d3a-605905fa9a40 | /documentation/ops-monitoring/memory-usage/ | Memory Usage | Understanding the Fields | documentation | true | Memory Usage > Understanding the Fields
The breakdown covers these components:
| Component | Description |
| --- | --- |
| **Total** | Aggregate across all components. |
| **Vectors** | Per dense and multi-dense vector: storage, index, and optionally quantization. |
| **Sparse Vectors** | Per sparse vector: storage a... | [
0.05208844318985939,
-0.04784009978175163,
-0.06713423132896423,
-0.05925730988383293,
0.07103009521961212,
-0.039325371384620667,
0.033085547387599945,
0.03426855430006981,
0.08806657046079636,
-0.037059374153614044,
0.022997964173555374,
0.009208522737026215,
0.03649050369858742,
-0.0406... |
7c05e2ab-b328-50c0-9ec8-5c607f1085d8 | /course/essentials/day-2/what-is-hnsw/ | HNSW Indexing Fundamentals | HNSW in Action | course | true | HNSW Indexing Fundamentals > HNSW in Action
### Why It Is Fast and Scalable
- **Sublinear Search Scaling**: Unlike O(N) brute force search, HNSW search grows roughly logarithmically with the number of vectors. This makes million-scale datasets searchable in milliseconds rather than minutes.
- **Filter‑Aware**: Qdran... | [
0.006792713887989521,
-0.0340842641890049,
-0.07593671977519989,
-0.0209346953779459,
0.0419480986893177,
-0.0363851897418499,
0.07940129190683365,
0.02728121355175972,
0.0758284330368042,
-0.016805963590741158,
0.03985206037759781,
0.03276190161705017,
0.055899105966091156,
0.001644842559... |
7c0f590c-c6b0-590e-b3b8-a2e6e09295fb | /documentation/search/text-search/sparse-vector-search/ | Sparse Vector Search | BM25 > BM25 Text Processing | documentation | false | Sparse Vector Search > BM25 > BM25 Text Processing
Before the sparse vector BM25 model can generate a vector for a text, Qdrant breaks the text down into individual tokens (words) and applies several normalization steps to them. This ensures that searches can match variations of words. For query tokens to match the in... | [
0.04329470172524452,
-0.07771801948547363,
-0.008987907320261002,
-0.024390147998929024,
0.0622575469315052,
-0.04985176399350166,
0.07006225734949112,
0.036843810230493546,
0.035649485886096954,
-0.01585664413869381,
0.05606351047754288,
0.04042048379778862,
0.03339951112866402,
-0.034564... |
7c197a1b-a1e9-5c1d-8116-c27f260d9b52 | /course/beginners/module-2/hnsw/ | Fast Approximate Search: HNSW | course | false | Fast Approximate Search: HNSW
Module 2
Searching millions of vectors by computing similarity against every single one (brute force) is slow. Qdrant uses HNSW (Hierarchical Navigable Small World), a graph-based approximate nearest neighbor (ANN) index that makes large-scale search fast at a small, measurable recall co... | [
0.038815487176179886,
-0.039908599108457565,
-0.07927819341421127,
-0.03289323300123215,
0.04322056472301483,
-0.03401891887187958,
0.07769393175840378,
0.03653433918952942,
0.06098170951008797,
-0.032267019152641296,
0.02887333743274212,
0.013858913443982601,
0.05285686254501343,
-0.00219... | |
7c1b1c5b-6352-507e-8471-87ac8f009172 | /articles/minicoil/ | miniCOIL: on the Road to Usable Sparse Neural Retrieval | Key Takeaways > What's Next? | article | false | miniCOIL: on the Road to Usable Sparse Neural Retrieval > Key Takeaways > What's Next?
We will continue working on improving our approach -- both in-depth, searching for ways to improve the model's quality, and in-width, extending it to various dense encoders and languages beyond English.
And we would love to share t... | [
0.04888200759887695,
-0.062122710049152374,
-0.010183671489357948,
-0.04973350092768669,
0.055748920887708664,
-0.07193688303232193,
0.0588165745139122,
0.03875856474041939,
0.051766764372587204,
-0.024052709341049194,
0.006075836718082428,
0.05157432705163956,
0.07663176953792572,
-0.0025... |
7c1d1991-75f4-5f8d-9d94-3be5612c2007 | /documentation/search/filtering/ | Filtering | Filtering Conditions > Is Empty | documentation | true | Filtering > Filtering Conditions > Is Empty
Sometimes it is also useful to filter out records that are missing some value.
The `IsEmpty` condition may help you with that:
```python
models.IsEmptyCondition(
is_empty=models.PayloadField(key="reports"),
)
```
This condition will match all records where the field `r... | [
0.019792266190052032,
-0.043495263904333115,
-0.04463060200214386,
-0.0681956559419632,
0.04615980386734009,
-0.005940917879343033,
0.031981755048036575,
0.029780680313706398,
0.04606984928250313,
-0.030685145407915115,
0.02652030624449253,
0.04782888665795326,
0.04330648481845856,
-0.0272... |
7c3bceff-0be9-57e1-ae4f-6876f7bade3e | /documentation/embeddings/voyage/ | Voyage AI | Embed Queries | documentation | true | Voyage AI > Embed Queries
Set `input_type` to `query` for search queries. Voyage AI prepends a retrieval prompt that differs for queries and documents, which tailors each vector for retrieval:
```python
query_vector = vo.embed(
["What is Qdrant?"], model="voyage-4-large", input_type="query"
).embeddings[0]
hits ... | [
0.04256446659564972,
-0.07155734300613403,
-0.04775030538439751,
-0.05131744593381882,
0.06948579102754593,
-0.0213442575186491,
0.04665468633174896,
0.049434419721364975,
0.03856322541832924,
-0.03887627273797989,
0.012005954049527645,
0.026220280677080154,
0.04891660436987877,
0.00395104... |
7c40ed0b-a809-58b8-85db-cf700a18f0ee | /documentation/private-cloud/logging-monitoring/ | Logging & Monitoring | Monitoring | documentation | false | Logging & Monitoring > Monitoring
The Qdrant Cloud console gives you access to basic metrics about CPU, memory and disk usage of your Qdrant clusters.
If you want to integrate Qdrant metrics into your own monitoring system, configure it to scrape the following endpoints, which provide metrics in a Prometheus/OpenMetr... | [
0.0217506792396307,
-0.03860468417406082,
-0.013327757827937603,
0.0025818697176873684,
0.06642117351293564,
-0.03420448303222656,
0.07537993788719177,
0.06984836608171463,
0.06187952682375908,
-0.051697712391614914,
0.018046876415610313,
-0.012229056097567081,
0.04388618469238281,
-0.0193... |
7c669ebb-2148-5698-98ec-0a78f917f8dc | /articles/agentic-rag/ | What is Agentic RAG? Building Agents with Qdrant | Where are Agents Used? | article | false | What is Agentic RAG? Building Agents with Qdrant > Where are Agents Used?
Agents are an interesting concept, but since they heavily rely on LLMs, they are not applicable to all problems. Using
Large Language Models is expensive and tend to be slow, what in many cases, it's not worth the cost. Standard RAG
involves ju... | [
-0.03380858525633812,
-0.04135013744235039,
-0.0651516318321228,
-0.02001757174730301,
0.08748547732830048,
-0.08318770676851273,
0.06801105290651321,
0.04024549573659897,
0.0721302479505539,
-0.049883559346199036,
0.03771227225661278,
0.025805937126278877,
0.058645471930503845,
-0.0081151... |
7c6dce8b-4f27-547d-ba8c-9920215fcc62 | /course/beginners/module-2/payload-filtering/ | Payload Filtering | course | true | Payload Filtering
Module 2
Payload filtering lets you apply hard conditions during HNSW traversal, not after retrieval. This keeps results both semantically relevant and legally/logically valid.
This searches by vector similarity as usual, but only among points whose payload passes the filter:
- `Filter` — the over... | [
0.0017594753298908472,
-0.04576907679438591,
-0.05750373750925064,
-0.023233819752931595,
0.05108058452606201,
-0.025634387508034706,
0.07338320463895798,
0.04047178104519844,
0.06292135268449783,
-0.026484856382012367,
0.03637504205107689,
0.04518420994281769,
0.019951116293668747,
-0.035... | |
7c862032-db1f-55a1-8678-e419051f663f | /documentation/ops-optimization/optimizer/ | Optimizer | Vacuum Optimizer | documentation | true | Optimizer > Vacuum Optimizer
The Vacuum Optimizer helps manage storage by handling deleted records. When a record is deleted, it isn't removed right away but marked as deleted to avoid slow disk operations during queries. While this improves performance, over time, these marked records can build up, wasting memory and... | [
-0.011699755676090717,
-0.0452386736869812,
-0.05445070192217827,
-0.03935479000210762,
0.05984041467308998,
-0.016784045845270157,
0.019179416820406914,
0.028081277385354042,
0.07993120700120926,
-0.017260337248444557,
0.015094124712049961,
0.05817435681819916,
0.034410979598760605,
-0.04... |
7ca23be5-7ea3-56d8-a272-03546df73c5d | /documentation/examples/graphrag-qdrant-neo4j/ | GraphRAG with Qdrant and Neo4j | Implementation > Prerequisites > Qdrant Setup | documentation | false | GraphRAG with Qdrant and Neo4j > Implementation > Prerequisites > Qdrant Setup
You can use [Qdrant Cloud](/documentation/cloud-quickstart/) or [run Qdrant yourself](/documentation/quickstart/). This tutorial uses Qdrant Cloud:
- Go to [Qdrant Cloud](https://cloud.qdrant.io/) and sign up or log in.
- Once logged in, c... | [
0.01694190874695778,
-0.04601649194955826,
-0.03537189960479736,
-0.011446893215179443,
0.0813414677977562,
-0.046852510422468185,
0.05256642401218414,
0.06277525424957275,
0.022563889622688293,
-0.05231762304902077,
0.024353472515940666,
0.00814257562160492,
0.08437315374612808,
-0.042541... |
7cde7c62-027d-59dc-8695-6a430c059dd8 | /course/essentials/day-1/pitstop-project/ | Project: Building a Semantic Search Engine | What You'll Build | course | false | Project: Building a Semantic Search Engine > What You'll Build
A working semantic search engine that demonstrates:
- **Domain expertise**: Choose content you understand so you can evaluate search quality
- **Chunking comparison**: Test different strategies and see which works best for your content type
- **Real seman... | [
0.008026941679418087,
-0.04691678285598755,
-0.06619925796985626,
-0.00651217857375741,
0.0364641472697258,
-0.0266898013651371,
0.030179327353835106,
0.022180825471878052,
0.05441897362470627,
-0.04444938153028488,
0.04857875034213066,
0.015683244913816452,
0.07821967452764511,
-0.0413262... |
7ce8cf41-6301-592f-bb1f-b46ab1e4cb54 | /documentation/hybrid-cloud/platform-deployment-options/ | Deployment Platforms | Google Cloud Platform (GCP) | documentation | true | Deployment Platforms > Google Cloud Platform (GCP)
[Google Kubernetes Engine (GKE)](https://cloud.google.com/kubernetes-engine) is a managed Kubernetes service that you can use to deploy and operate containerized applications at scale using Google's infrastructure. GKE provides the operational power of Kubernetes whil... | [
-0.006033779121935368,
-0.027731815353035927,
-0.07333055138587952,
-0.04227864369750023,
0.053698793053627014,
-0.007503155618906021,
0.07852047681808472,
0.053441133350133896,
0.07279586046934128,
-0.04861839860677719,
0.03899562358856201,
0.012867126613855362,
-0.010709412395954132,
-0.... |
7ce999d1-a4d3-5e1c-88d8-7f6325404b1a | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | Vector Search Beyond RAG > Fundamentally Different | article | false | Why Vector Search Needs a Dedicated Database > Vector Search Beyond RAG > Fundamentally Different
**Vector search beyond RAG isn't just another feature — it's a fundamental shift in how we interact with data**. Dedicated solutions integrate these capabilities natively and are designed from the ground up to handle high... | [
0.014955192804336548,
-0.04649636149406433,
-0.08323755115270615,
-0.04140554368495941,
0.056095097213983536,
-0.028152912855148315,
0.01954108476638794,
0.008935835212469101,
0.08344096690416336,
-0.0254544485360384,
0.025147756561636925,
0.05782835930585861,
0.05319008603692055,
-0.01203... |
7cf09176-00b4-5abf-8f1e-55ba7e5466d1 | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Search > What is the default value of hnsw_ef during search? | documentation | false | Qdrant Fundamentals > Search > What is the default value of hnsw_ef during search?
By default, `hnsw_ef` equals `ef_construct` (default: 100). `ef_construct` is a collection-level configuration that controls the number of neighbors considered during graph construction. `hnsw_ef` is the per-query parameter controlling ... | [
0.03560158610343933,
-0.04463275521993637,
-0.060207806527614594,
-0.024364588782191277,
0.01897660829126835,
-0.06237668916583061,
0.07368088513612747,
0.06016502156853676,
0.07817099988460541,
-0.018484575673937798,
0.04542470723390579,
0.00945326779037714,
0.03735273331403732,
-0.030484... |
7cff6e58-b7f8-5508-9e06-b7303dfe59be | /documentation/manage-data/vectors/ | Vectors | Datatypes > TurboQuant Datatypes > Turbo8 | documentation | true | Vectors > Datatypes > TurboQuant Datatypes > Turbo8
*Available as of v1.20.0*
The `turbo8` datatype stores each vector as an 8-bit representation per dimension instead of a 32-bit floating-point number. This shrinks vector storage to about one-quarter of its original size.
To use `turbo8`, specify the `turbo8` datat... | [
0.029161833226680756,
-0.04668264463543892,
-0.04320209473371506,
-0.0450814813375473,
0.008812669664621353,
-0.035496506839990616,
0.027194248512387276,
0.04030260816216469,
0.07642436027526855,
-0.021067284047603607,
0.07416163384914398,
0.041573140770196915,
0.05569728463888168,
-0.0049... |
7d17bd0b-3418-5c88-abb1-d0b3a0d6dc4a | /documentation/search/filtering/ | Filtering | Filtering Conditions > Has Vector | documentation | true | Filtering > Filtering Conditions > Has Vector
*Available as of v1.13.0*
This condition enables filtering by the presence of a given named vector on a point.
For example, if we have two named vector in our collection.
```http
PUT /collections/{collection_name}
{
"vectors": {
"image": {
"size"... | [
0.05759352445602417,
-0.05827215313911438,
-0.03823694586753845,
-0.03382183983922005,
0.05756079778075218,
-0.05071959272027016,
0.04109462723135948,
0.0464569628238678,
0.06705766916275024,
-0.013993728905916214,
0.031201442703604698,
0.081144317984581,
0.08029387891292572,
-0.0200864989... |
7d1c1974-2b67-567a-b9ee-674412839da2 | /articles/universal-io/ | Universal I/O in Qdrant | article | false | Universal I/O in Qdrant
The code snippets in this blog are pseudo-Rust. They simplify the real code (for example, by dropping generics, trait bounds, lifetimes, and error handling) to show the idea, but they are not working code and are not meant to compile. | [
0.05108998343348503,
-0.05855359137058258,
-0.04798417165875435,
-0.028901081532239914,
0.05959157273173332,
-0.036169130355119705,
0.051241129636764526,
-0.009452409110963345,
0.044024329632520676,
-0.022467568516731262,
0.04079720750451088,
0.0358111709356308,
0.04991861432790756,
-0.019... | |
7d223a5c-f9c6-5863-880a-1d242417d769 | /course/essentials/day-3/sparse-retrieval-demo/ | Demo: Keyword Search with Sparse Vectors | The Idea Behind Sparse Text Retrieval | course | true | Demo: Keyword Search with Sparse Vectors > The Idea Behind Sparse Text Retrieval
If texts are represented as sparse vectors, their similarity can be computed with the **dot product**.
```text
Similarity("Grated hard cheese", "Mac and cheese") = 1.0 * 1.0 = 1.0
Similarity("Grated hard cheese", "four cheese pizza for ... | [
0.060871828347444534,
-0.03359676152467728,
-0.014747243374586105,
-0.06703678518533707,
0.06772822141647339,
-0.057129472494125366,
0.07298212498426437,
0.013894524425268173,
0.07689842581748962,
-0.01994197629392147,
0.011293822899460793,
0.015914801508188248,
0.046651218086481094,
-0.01... |
7d273b0f-3e6d-583d-9b1b-ad08a0b3e6f2 | /documentation/fastembed/fastembed-splade/ | Working with SPLADE | Retrieve embeddings | documentation | true | Working with SPLADE > Retrieve embeddings
`sparse_embeddings_list` contains sparse embeddings for the documents provided earlier. Each element in this list is a `SparseEmbedding` object that contains the sparse vector representation of a document.
```python
index = 0
sparse_embeddings_list[index]
```
This output is ... | [
0.04308893904089928,
-0.054457876831293106,
-0.010928135365247726,
-0.07523920387029648,
0.07362459599971771,
-0.03418239206075668,
0.05972626432776451,
0.07856986671686172,
0.034868013113737106,
-0.0243369210511446,
0.013922546990215778,
0.05002579465508461,
0.028851600363850594,
-0.00526... |
7d437d57-5af5-5bd7-a00c-db37806759c9 | /articles/dedicated-vector-search/ | Why Vector Search Needs a Dedicated Database | article | false | Why Vector Search Needs a Dedicated Database
Any problem with even a bit of complexity requires a specialized solution. You can use a Swiss Army knife to open a bottle or poke a hole in a cardboard box, but you will need an axe to chop wood — the same goes for software.
In this article, we will describe the unique ch... | [
0.005453249905258417,
-0.08660953491926193,
-0.04069546237587929,
-0.045906130224466324,
0.04161012917757034,
-0.049525897949934006,
0.05606425553560257,
0.024299072101712227,
0.056538887321949005,
0.023421386256814003,
0.02267373725771904,
0.04627319797873497,
0.05536724627017975,
-0.0605... | |
7d45a9b9-3cdf-5d47-8f75-6207e6495ee7 | /articles/what-are-embeddings/ | Vector Embeddings Explained: How They Work in ML & Search | How do embeddings work? > Creating vector embeddings | article | false | Vector Embeddings Explained: How They Work in ML & Search > How do embeddings work? > Creating vector embeddings
More advanced models like [BERT](https://en.wikipedia.org/wiki/BERT_(language_model)) and [GPT](https://en.wikipedia.org/wiki/Generative_pre-trained_transformer) use deep learning models based on the [trans... | [
0.05752966180443764,
-0.014622839167714119,
-0.06626104563474655,
-0.02591361291706562,
0.05889647454023361,
-0.004047703463584185,
0.06122291460633278,
0.041228748857975006,
0.06691668927669525,
-0.02434011735022068,
0.01947767101228237,
0.0016229454195126891,
0.04668800160288811,
-0.0263... |
7d4f5f1d-424a-5b0e-b55b-825444371c22 | /articles/modern-sparse-neural-retrieval/ | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ | Sparse Neural Retrieval Evolution | article | false | Modern Sparse Neural Retrieval: From DeepCT to SPLADE++ > Sparse Neural Retrieval Evolution
Imagine searching for a “*flabbergasting murder*” story.
”*Flabbergasting*” is a rarely used word, so a keyword-based retriever, for example, BM25, will assign huge importance to it.
Consequently, there is a high chance that ... | [
0.03810695558786392,
-0.04716594144701958,
-0.03552759066224098,
-0.03226189315319061,
0.0504160150885582,
-0.033690501004457474,
0.05493929237127304,
0.0283630583435297,
0.06695622950792313,
-0.018753277137875557,
0.003953409846872091,
0.03199972212314606,
0.06104717776179314,
-0.04148934... |
7d5cdcaf-b7f6-5a5e-bed1-2035eb49a5aa | /course/beginners/module-1/further-reading/ | Further Reading | course | false | Further Reading
Module 1
- [Distance Metrics](/course/essentials/day-1/distance-metrics/) Learn more about cosine similarity, dot product, and Euclidean distance.
- [Vector Embeddings Explained](/articles/what-are-embeddings/) A deeper introduction to how embedding models turn data into vectors.
- [FastEmbed](/docume... | [
0.06977001577615738,
-0.021240053698420525,
-0.03398716449737549,
-0.017522377893328667,
0.06582759320735931,
-0.03885235637426376,
0.06112826615571976,
0.07570706307888031,
0.08107089251279831,
-0.0241289921104908,
0.03191547468304634,
0.02299906313419342,
0.032994989305734634,
-0.0111661... | |
7d81dbe1-1c32-52d9-a1fa-3c6e2161dafa | /documentation/tutorials-search-engineering/branch-aware-search/ | Branch-Aware Search | Step 1: Add a File | documentation | true | Branch-Aware Search > Step 1: Add a File
Start with a single `root` branch and one commit that adds a file.
```text
root ● seq 0: add pricing.md
```
A commit is numbered with a per-branch `seq` (`0`, `1`, `2`, ...). Each file it writes becomes a point tagged with the `branch` that wrote it, the `seq`, an... | [
0.01569495163857937,
-0.045959461480379105,
-0.026568371802568436,
0.0019365001935511827,
0.05231796205043793,
-0.035889431834220886,
0.009196112863719463,
0.10650432109832764,
0.05286155641078949,
-0.01355304941534996,
0.03962413966655731,
0.04603860527276993,
0.009116976521909237,
-0.041... |
7d82fcfb-4871-5213-8480-cc7c41268ef1 | /documentation/examples/rag-contract-management-stackit-cohere/ | Region-Specific Contract Management System | Implementation > Search application | documentation | true | Region-Specific Contract Management System > Implementation > Search application
Specialized Document Management Systems have a lot of features, but semantic search is not yet a standard. We are going
to build a simple search mechanism which could be possibly integrated with the existing system. The search process is
... | [
0.028767326846718788,
-0.07821035385131836,
-0.05406015366315842,
0.0010287448531016707,
0.0517602376639843,
-0.03591518476605415,
0.06290628015995026,
0.0264416690915823,
0.08451729267835617,
-0.010666369460523129,
0.009202491492033005,
0.004919365979731083,
0.07339134067296982,
-0.055128... |
7d987150-ca65-5bdb-8d57-fc204aa3c6bc | /documentation/tutorials-search-engineering/using-multivector-representations/ | Multivectors and Late Interaction | Conclusion | documentation | false | Multivectors and Late Interaction > Conclusion
Multivector search is one of the most powerful features of a vector database when used correctly. With this functionality in Qdrant, you can:
- Store token-level embeddings natively.
- Disable indexing to reduce overhead.
- Run fast retrieval and accurate reranking in ... | [
0.022717393934726715,
-0.03045460768043995,
-0.04919713735580444,
-0.053131103515625,
0.062186192721128464,
-0.04115060716867447,
0.0972796306014061,
0.022095974534749985,
0.07214519381523132,
-0.02040746994316578,
0.015713686123490334,
0.029850102961063385,
0.04334910959005356,
-0.0260766... |
7d9efbd0-7fd7-54c0-a572-148cc13a61fc | /documentation/frameworks/google-adk/ | Google ADK | documentation | true | Google ADK
[Agent Development Kit (ADK)](https://github.com/google/adk-python) is an open-source, code-first Python framework from Google for building, evaluating, and deploying sophisticated AI agents. While optimized for Gemini, ADK is model-agnostic and compatible with other frameworks.
You can connect ADK agents ... | [
0.052771374583244324,
-0.03978905826807022,
-0.07427964359521866,
-0.037869084626436234,
0.03966295346617699,
-0.04471616446971893,
0.0713338553905487,
0.05188732221722603,
0.04538960009813309,
-0.0808493047952652,
0.0666188970208168,
0.022270163521170616,
0.014405538327991962,
-0.03674383... | |
7daeb28f-41de-5a26-bd8e-33ea632bead6 | /documentation/ops-monitoring/monitoring/ | Monitoring & Telemetry | Metrics > Node Metrics /metrics | documentation | false | Monitoring & Telemetry > Metrics > Node Metrics /metrics
| Name | Type | Meaning |
| ------------------------------------------------- | ------- | ------------------------------... | [
-0.018482631072402,
-0.018584569916129112,
-0.03984720632433891,
-0.0123983696103096,
0.05455101281404495,
-0.012450650334358215,
0.058491311967372894,
0.09139196574687958,
0.08444570004940033,
-0.04516759514808655,
0.0425366535782814,
0.015355073846876621,
0.025860829278826714,
0.01187988... |
7dcd9c5d-5bea-5cde-b0ab-8fd360fda3b0 | /documentation/search/low-latency-search/ | Low-Latency Search | Query Indexed Data Only > prevent_unoptimized Optimizer Setting | documentation | false | Low-Latency Search > Query Indexed Data Only > prevent_unoptimized Optimizer Setting
*Available as of v1.17.1*
prevent_unoptimized is an experimental feature; its behavior may change slightly in future releases and it must be used with care.
To mitigate "blinking" points, an alternative to using `indexed_only` is to... | [
0.046929050236940384,
-0.03928254172205925,
-0.038389772176742554,
-0.018743766471743584,
0.059529636055231094,
-0.03800283744931221,
0.007362181320786476,
0.051333948969841,
0.061606306582689285,
-0.021957462653517723,
0.03946553170681,
0.020635316148400307,
0.06581608206033707,
-0.043349... |
7dd03b64-cd36-5214-9fd2-ad7b7ca943d5 | /documentation/ops-configuration/ | Configuration | documentation | false | Configuration
These pages cover the settings and runtime options available for customizing and administering a Qdrant deployment.
## Configuration
[Configuration](/documentation/ops-configuration/configuration/) describes how to customize Qdrant's behavior using config files and environment variables, covering stora... | [
0.046429187059402466,
-0.054147928953170776,
-0.049973953515291214,
-0.03561035171151161,
0.0650010034441948,
-0.027192268520593643,
0.04908624291419983,
0.07004933804273605,
0.08595713973045349,
-0.02617333084344864,
0.035054050385951996,
-0.009596887975931168,
0.018058115616440773,
-0.06... | |
7de0bee8-958d-5b4f-b6d0-b57b4e3210af | /documentation/faq/qdrant-fundamentals/ | Qdrant Fundamentals | Vectors > Should each chunk of my document be a separate point in Qdrant? | documentation | false | Qdrant Fundamentals > Vectors > Should each chunk of my document be a separate point in Qdrant?
Yes, in most Retrieval-Augmented Generation (RAG) setups, each chunk is stored as a separate point. The chunk text (or a reference to it) goes in the payload, and the embedding of that chunk is the vector. Points can share ... | [
0.026072025299072266,
-0.05413578450679779,
-0.036653075367212296,
-0.03511689975857735,
0.04398807883262634,
-0.04865408316254616,
0.06103828549385071,
0.0468389093875885,
0.056466322392225266,
-0.043290358036756516,
0.008583931252360344,
-0.00034135582973249257,
0.04137526452541351,
-0.0... |
7e09250b-9494-5190-b211-a8ad9cacc092 | /documentation/migrate-to-qdrant/from-opensearch/ | From OpenSearch | Run the Migration | documentation | true | From OpenSearch > Run the Migration
```bash
docker run --net=host --rm -it registry.cloud.qdrant.io/library/qdrant-migration opensearch \
--opensearch.url 'https://your-opensearch-host:9200' \
--opensearch.index 'your-index' \
--opensearch.username 'admin' \
--opensearch.password 'your-password' \
... | [
0.05394865572452545,
-0.0833079069852829,
-0.03196794539690018,
-0.013513421639800072,
0.06975853443145752,
-0.031129399314522743,
0.05862092599272728,
0.0516548715531826,
0.056428153067827225,
-0.04727349802851677,
0.01634923368692398,
0.0023697295691818,
0.048246193677186966,
-0.03980696... |
7e146ad3-8b2b-5faa-b135-21aee018d44d | /documentation/production-operations/predictable-search-latency/ | Configure Qdrant's Optimizer for Predictable Search Latency | How We Measured It | documentation | false | Configure Qdrant's Optimizer for Predictable Search Latency > How We Measured It
- All 13 collections lived on the same node for the whole test, so absolute latencies include that machine's baseline overhead. Read them as relative effects, not as a latency SLA for your own cluster.
- The embeddings come from the `Cohe... | [
0.03756779432296753,
-0.03422630950808525,
-0.055385202169418335,
-0.03369230777025223,
0.06359215825796127,
-0.06323222815990448,
0.03615880385041237,
0.07265971601009369,
0.09617919474840164,
-0.06740986555814743,
0.035030562430620193,
0.015870457515120506,
0.054119810461997986,
-0.02063... |
7e1b9acf-ca4c-524e-9cec-e343e60b1a36 | /documentation/tutorials-operations/large-scale-search/ | Large-Scale Search | Memory Usage > Size of IDs and versions | documentation | true | Large-Scale Search > Memory Usage > Size of IDs and versions
Qdrant must store additional information about each point, such as ID and version.
This information is needed on each request, so it is very important to keep it in RAM for fast access.
Let's take a look at Qdrant internals to understand how much memory is... | [
0.012527457438409328,
-0.027003513649106026,
-0.010557234287261963,
-0.007868116721510887,
0.03801644593477249,
-0.03102274052798748,
0.04936756193637848,
0.05525115504860878,
0.11448752880096436,
-0.048118628561496735,
0.015118604525923729,
0.009786507114768028,
0.06626749783754349,
-0.00... |
7e302ff8-93ef-505d-80db-0ee4b93a9baf | /documentation/tutorials-build-essentials/rag-deepseek/ | 5-Minute RAG with DeepSeek | Setup DeepSeek > Extending the prompt | documentation | true | 5-Minute RAG with DeepSeek > Setup DeepSeek > Extending the prompt
Even though the original answer sounds credible, it didn't answer our question correctly. Instead, it gave us a generic description of an application stack. To improve the results, enriching the original prompt with the descriptions of the tools availa... | [
0.039401426911354065,
-0.07021673768758774,
-0.03817536309361458,
-0.040506087243556976,
0.053095828741788864,
-0.024853313341736794,
0.0510726198554039,
0.01831790991127491,
0.06560777127742767,
-0.06057724356651306,
0.047650959342718124,
-0.011414467357099056,
0.07133182138204575,
-0.018... |
7e3ab5d6-df33-5368-a6e4-e56f1251d6bb | /documentation/data-synchronization/with-postgres/ | Keeping Postgres and Qdrant in Sync | Tier 3: Change Data Capture with Debezium + Redpanda > Failure Modes | documentation | false | Keeping Postgres and Qdrant in Sync > Tier 3: Change Data Capture with Debezium + Redpanda > Failure Modes
| Failure | Consequence | Mitigation |
| :---- | :---- | :---- |
| Qdrant is down | Consumer pauses; Redpanda retains events | Consumer retries; resumes from offset on recovery |
| Redpanda is down | Debezium buf... | [
0.0758059024810791,
-0.028762251138687134,
-0.004689945373684168,
-0.02488270401954651,
0.03007940948009491,
-0.05287422239780426,
0.07634874433279037,
0.0448845699429512,
0.06057777628302574,
-0.02407585270702839,
0.05779499560594559,
0.02998325601220131,
0.014181400649249554,
-0.04781755... |
7e5cd136-4320-568c-a8f8-027d6f28aa21 | /documentation/tutorials-basics/huggingface-datasets/ | Hugging Face Dataset Ingestion | arxiv-titles-instructorxl-embeddings > Loading the Dataset into Qdrant | documentation | true | Hugging Face Dataset Ingestion > arxiv-titles-instructorxl-embeddings > Loading the Dataset into Qdrant
You can load the dataset into Qdrant using the [Python SDK](https://github.com/qdrant/qdrant-client).
The embeddings are already precomputed, so you can store them in a collection that we're going
to create in a sec... | [
0.0378151573240757,
-0.04517673701047897,
-0.039574701339006424,
-0.026557065546512604,
0.07906975597143173,
-0.044874805957078934,
0.05046167969703674,
0.03722517192363739,
0.06602928042411804,
-0.034019917249679565,
0.04883025959134102,
0.043491337448358536,
0.030889173969626427,
-0.0372... |
7e63fb26-3aff-53cd-b8f8-36631bbe3164 | /documentation/tutorials-basics/search-beginners/ | Semantic Search 101 | Next Steps | documentation | false | Semantic Search 101 > Next Steps
Congratulations, you have just created your very first search engine! Trust us, the rest of Qdrant is not that complicated, either. For your next tutorial, try [building your own hybrid search service](/documentation/tutorials-basics/cloud-inference-hybrid-search/) or take the free [Qd... | [
0.031297292560338974,
-0.04075849428772926,
-0.01840835064649582,
-0.012856817804276943,
0.04479071870446205,
-0.048961348831653595,
0.05165048688650131,
0.0052493722178041935,
0.05501696839928627,
-0.022163797169923782,
0.060026343911886215,
0.02292473055422306,
0.07838645577430725,
-0.06... |
7e6670e6-0700-539d-83c4-0ee184ea65c3 | /documentation/production-operations/vector-search-in-production/ | Vector Search in Production: Scaling, HA & Tuning Guide | 1. How Can You Get the Best Search Performance? > Index Your Important Metadata to Avoid Costly Queries | documentation | false | Vector Search in Production: Scaling, HA & Tuning Guide > 1. How Can You Get the Best Search Performance? > Index Your Important Metadata to Avoid Costly Queries
You should always [**create payload indexes**](https://qdrant.tech/documentation/manage-data/indexing/#payload-index) for all fields used in filters or sorti... | [
0.014764825813472271,
-0.05340231955051422,
-0.0595334954559803,
-0.0137485908344388,
0.040607601404190063,
-0.04119965434074402,
0.04184597730636597,
0.02596629410982132,
0.09418679028749466,
-0.05002809688448906,
0.03735009953379631,
0.03180050477385521,
0.02659434638917446,
-0.049287918... |
7e7ce008-e358-58a1-bf10-853cb874c889 | /documentation/ops-configuration/quotas/ | Resource Quotas | When a Quota Is Exceeded > Finding the Node That Is Full | documentation | true | Resource Quotas > When a Quota Is Exceeded > Finding the Node That Is Full
Use the `GET /quotas` API to check quotas on the whole cluster:
```json
{
"config": {"enabled": true, "max_disk_usage_percent": 90},
"usage": {"resident_memory_percent": 12, "disk_usage_percent": 46},
"peers": {
"3421...": {"residen... | [
0.034025803208351135,
-0.033019524067640305,
-0.042518891394138336,
-0.026709282770752907,
0.05308856815099716,
-0.008702367544174194,
0.024373859167099,
0.04200344532728195,
0.09184158593416214,
-0.04958415403962135,
0.015780871734023094,
0.00970892608165741,
0.033267538994550705,
-0.0580... |
7e82a0dc-5ceb-5ed3-a1e0-3b114e97e16c | /documentation/frameworks/nlweb/ | Microsoft NLWeb | documentation | true | Microsoft NLWeb
Microsoft's [NLWeb](https://github.com/nlweb-ai/NLWeb) is a proposed framework that enables natural language interfaces for websites, using Schema.org, formats like RSS and the emerging [MCP protocol](https://github.com/nlweb-ai/NLWeb/blob/main/docs/nlweb-rest-api.md).
Qdrant is supported as a vector ... | [
0.07190520316362381,
-0.03258402645587921,
-0.04278619959950447,
-0.03304683789610863,
0.059283386915922165,
-0.037936825305223465,
0.06892218440771103,
0.05981827527284622,
0.07113665342330933,
-0.027262862771749496,
-0.009160758927464485,
0.00798651110380888,
0.0661899596452713,
-0.05630... | |
7e851cfa-1251-577c-82f7-1395c11289d1 | /documentation/fastembed/ | FastEmbed | Using FastEmbed | documentation | false | FastEmbed > Using FastEmbed
[Browse supported models](/documentation/embeddings/fastembed/) to compare embedding model dimensions and licenses.
| Type | Guide | What you'll learn ... | [
0.04481884837150574,
-0.020410560071468353,
-0.011505892500281334,
-0.03953611105680466,
0.0908762589097023,
-0.051230721175670624,
0.07440725713968277,
0.036985982209444046,
0.04236457496881485,
-0.04071817547082901,
0.047498468309640884,
0.039728205651044846,
0.0468352772295475,
-0.02805... |
7e9c9a5f-8229-5f3b-98bb-29272437adb7 | /documentation/tutorials-search-engineering/using-multivector-representations/ | Multivectors and Late Interaction | What is Rescoring, and Why is it Used? | documentation | false | Multivectors and Late Interaction > What is Rescoring, and Why is it Used?
Rescoring is two-fold:
- Retrieve relevant documents using a fast model.
- Rerank them using a more accurate but slower model such as ColBERT. | [
0.01809273660182953,
-0.0014272482367232442,
-0.05379406362771988,
-0.059526294469833374,
0.08276389539241791,
-0.011054172180593014,
0.05972304567694664,
0.0026057048235088587,
0.0651208758354187,
-0.009349927306175232,
0.004898604936897755,
-0.0012685083784162998,
0.0615227073431015,
0.0... |
7ea6edb5-a058-58f0-8bbb-0e3f8466dcda | /articles/relevance-feedback/ | Relevance Feedback in Qdrant | Experiments > Metric > Abovethreshold@N | article | false | Relevance Feedback in Qdrant > Experiments > Metric > Abovethreshold@N
A custom metric to compare vanilla retriever versus relevance feedback-based scoring.
**How we computed it (per query):**
We looked at N positions after the top-K documents used for mining context pairs (positions K+1 through K+N).
* **Vanilla r... | [
0.03794324770569801,
-0.024559056386351585,
-0.04972146824002266,
-0.051127173006534576,
0.06227791681885719,
-0.024906203150749207,
0.02443687617778778,
0.021618731319904327,
0.07353135198354721,
0.0003463529283180833,
0.030270298942923546,
0.000041511641029501334,
0.09039004147052765,
-0... |
7ea8edc5-4fba-5bcf-a2ad-cddc672a3285 | /course/multi-vector-search/module-2/how-colpali-works/ | How ColPali Models Work | Implementing Multi-Modal Search with FastEmbed and Qdrant | course | false | How ColPali Models Work > Implementing Multi-Modal Search with FastEmbed and Qdrant
Now that you understand ColPali's architecture - from its VLM foundation to patch-based processing to multi-vector embeddings - let's build a practical multi-modal search system. We'll again use **FastEmbed**, as it also provides a uni... | [
0.03554488718509674,
-0.029609987512230873,
-0.043264761567115784,
-0.03315461426973343,
0.09634357690811157,
-0.026880066841840744,
0.08516440540552139,
0.027468068525195122,
0.024127013981342316,
0.0033094582613557577,
0.044966962188482285,
-0.019774964079260826,
0.0363595150411129,
-0.0... |
7ed22033-5ab3-5f56-8a27-b026d25f6a07 | /documentation/tutorials-search-engineering/sparse-embeddings-ecommerce-part-5/ | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product | One-Line Python API | documentation | true | Fine-Tuning Sparse Embeddings for E-Commerce Search | Part 5: From Research to Product > One-Line Python API
For notebooks and scripts, the same pipeline is available as a function call:
```python
from qdrant_finetune import finetune
model_path = finetune("products.csv")
```
That single line:
1. Loads your product ... | [
0.049539417028427124,
-0.0694570317864418,
-0.024242671206593513,
-0.050536636263132095,
0.0317767895758152,
-0.017124878242611885,
0.07521599531173706,
0.036741532385349274,
0.06434478610754013,
0.00936416257172823,
0.021421091631054878,
0.02767317183315754,
0.05426780506968498,
-0.005219... |
7ee72a5a-8eb7-5bbb-b8b2-6f24e4c7719f | /articles/scalar-quantization/ | Scalar Quantization for Vector Search | Benchmarks | article | false | Scalar Quantization for Vector Search > Benchmarks
These benchmarks were run in March 2023 on Qdrant v1.1.0, the release that introduced scalar quantization. The hardware was not recorded, so read them as a historical comparison, not as current performance.
We simply used the same approach as we use in all [the other... | [
0.045690715312957764,
-0.030020153149962425,
-0.03647318109869957,
-0.03437408432364464,
0.05753776431083679,
-0.02530265413224697,
0.04945669695734978,
0.04564708098769188,
0.06795971095561981,
-0.046663038432598114,
0.05057331919670105,
0.035113293677568436,
0.03194401413202286,
-0.06142... |
7ee99994-29c7-5db6-9436-383dec63f7f1 | /articles/sparse-vectors/ | Understanding SPLADE and Sparse Vectors | Term expansion and weights | article | true | Understanding SPLADE and Sparse Vectors > Term expansion and weights
```python
def extract_and_map_sparse_vector(vector, tokenizer):
"""
Extracts non-zero elements from a given vector and maps these elements to their human-readable tokens using a tokenizer. The function creates and returns a sorted dictionary ... | [
0.05020105838775635,
-0.032691288739442825,
-0.04267333447933197,
-0.05491352081298828,
0.05086271092295647,
-0.0641687735915184,
0.03576009348034859,
0.04239711910486221,
0.06901419162750244,
-0.03825419396162033,
0.052313461899757385,
-0.009558087214827538,
0.01688959263265133,
-0.009514... |
7eec12c7-9f1e-528a-8fb3-297803595265 | /articles/io_uring/ | Faster Disk I/O for Vector Search Using io_uring | Input+Output | article | false | Faster Disk I/O for Vector Search Using io_uring > Input+Output
Around the mid-90s, the internet took off. The first servers used a process-
per-request setup, which was good for serving hundreds if not thousands of
concurrent request. The POSIX Input + Output (IO) was modeled in a strictly
synchronous way. The overhe... | [
0.026750847697257996,
-0.054040271788835526,
-0.04202205687761307,
0.005727308802306652,
0.06165354326367378,
-0.022032974287867546,
0.036432549357414246,
-0.01993824914097786,
0.09755183011293411,
-0.000777627166826278,
-0.009507899172604084,
-0.005913522094488144,
0.06252721697092056,
-0... |
7efe0a56-be86-513c-a4e3-48b4fe7931c4 | /documentation/embeddings/upstage/ | Upstage | Models | documentation | false | Upstage > Models
| Model | Dimensions | Max Tokens per Input | Role |
|---|---|---|---|
| `solar-embedding-2-passage` | 1024 | 8,000 | Documents |
| `solar-embedding-2-query` | 1024 | 8,000 | Queries |
`solar-embedding-1-large-passage` and `solar-embedding-1-large-query` are the previous generation, with 4096-dimensi... | [
0.033282700926065445,
-0.014466509222984314,
-0.03120913729071617,
-0.05683376267552376,
0.0640554428100586,
-0.05935110151767731,
0.017298750579357147,
0.061401255428791046,
0.0825963020324707,
-0.06567386537790298,
0.01617366448044777,
-0.0020473443437367678,
0.01342290174216032,
-0.0440... |
7eff9ffb-0dfd-529d-8c61-7df3547b265a | /documentation/edge/edge-api/configuration/ | Configuration | Optimizer Parameters | documentation | true | Configuration > Optimizer Parameters
`EdgeOptimizersConfig` controls what the [`optimize`](#optimize) method does when you call it.
```python
EdgeOptimizersConfig(
deleted_threshold: Optional[float] = None,
vacuum_min_vector_number: Optional[int] = None,
default_segment_number: Optional[int] = None,
m... | [
0.03313984349370003,
-0.041655007749795914,
-0.06503411382436752,
-0.027600351721048355,
0.05388437956571579,
-0.02457594871520996,
0.03454503417015076,
0.03566180169582367,
0.05109497159719467,
-0.033758506178855896,
0.04954642802476883,
0.010487633757293224,
0.03202889859676361,
-0.04341... |
7f17a8b7-1bcb-5c30-9cae-36da86793233 | /documentation/manage-data/indexing/ | Indexing | Payload Index > Block Queries That Filter on Unindexed Fields | documentation | false | Indexing > Payload Index > Block Queries That Filter on Unindexed Fields
Queries that filter on unindexed fields are not only slower; they can also unnecessarily consume cluster resources, negatively impacting the latency of other search queries. To prevent that, Qdrant provides an option to block queries that filter ... | [
0.0635082796216011,
-0.014779268763959408,
-0.05596815049648285,
-0.02943287044763565,
0.06779273599386215,
-0.02548401616513729,
0.03757718950510025,
0.027821417897939682,
0.07028385251760483,
-0.03493368625640869,
0.021533360704779625,
0.029633566737174988,
0.05917441472411156,
-0.018800... |
7f1f4e51-f9db-5cb0-858c-e36f99c8d279 | /documentation/cloud/configure-cluster/ | Configure Clusters | Shard Rebalancing | documentation | false | Configure Clusters > Shard Rebalancing
Qdrant Cloud continuously monitors the distribution of shards across your cluster's nodes and rebalances them in the background to keep data evenly distributed. This also happens whenever you scale your cluster horizontally. The rebalancing target is the total shard count and/or ... | [
0.02856021746993065,
-0.01420982088893652,
-0.06265980005264282,
-0.06283953040838242,
0.06508577615022659,
-0.02536173351109028,
0.0483173169195652,
0.02445339411497116,
0.08841373771429062,
-0.03540918976068497,
0.05024385079741478,
0.0002926945162471384,
0.06109258905053139,
-0.02945208... |
7f1f922e-c1ad-5d3f-82cb-bb7f822792a0 | /course/beginners/module-6/diversity-mmr/ | Diversity: Maximal Marginal Relevance | course | false | Diversity: Maximal Marginal Relevance
Module 6
Maximal Marginal Relevance (MMR) picks results one at a time, preferring candidates that match the query and differ from what it has already picked. In Qdrant it is a parameter on a nearest neighbors query, and `diversity` sets how much relevance it trades for variety.
... | [
0.026642005890607834,
-0.04416612535715103,
-0.05470675602555275,
-0.04253065958619118,
0.05211945250630379,
-0.015219544991850853,
0.041408974677324295,
0.060200802981853485,
0.08446582406759262,
-0.02775903046131134,
0.016183635219931602,
-0.0006974033894948661,
0.06333152204751968,
0.00... | |
7f26b686-3101-5b41-8fdb-7331c4de5202 | /documentation/tutorials-search-engineering/using-relevance-feedback/ | Relevance Feedback Retrieval in Qdrant | Evaluation | documentation | true | Relevance Feedback Retrieval in Qdrant > Evaluation
Empirically, Relevance Feedback Query results on the query above looked relevant. Yet we can imagine that might not be enough to justify adding additional complexity to your pipeline.
The framework we released also provides an evaluation block.
Analogously, we've ... | [
0.02054545469582081,
-0.027681367471814156,
-0.05980147421360016,
-0.06032672896981239,
0.054357223212718964,
-0.02375086583197117,
0.03903258219361305,
0.032134223729372025,
0.06433043628931046,
-0.027662497013807297,
0.008231157436966896,
0.011663220822811127,
0.06528832763433456,
-0.016... |
7f31f936-53ce-5560-9b92-3bbd3d627694 | /documentation/private-cloud/api-reference/ | API Reference | qdrant.io/v1 > Resource Types > Monitoring | documentation | false | API Reference > qdrant.io/v1 > Resource Types > Monitoring
_Appears in:_
- [QdrantCloudRegionStatus](#qdrantcloudregionstatus)
| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `cAdvisorMetricSource` _[MetricSource](#metricsource)_ | CAdvisorMetricSource specifies the cAdvisor metric source |... | [
0.04309602826833725,
-0.019500726833939552,
0.006236848421394825,
-0.0555904395878315,
0.049966517835855484,
-0.002717234194278717,
0.08815930038690567,
0.07621988654136658,
0.04822325333952904,
-0.050102416425943375,
0.04589497670531273,
-0.014349525794386864,
0.054379068315029144,
-0.031... |
7f67b395-4c68-5076-8782-0371a121c581 | /course/essentials/day-7/ | Day 7: Partner Ecosystem Integrations (Bonus) | course | false | Day 7: Partner Ecosystem Integrations (Bonus)
Day 7
Explore the Qdrant ecosystem and learn how to integrate with leading AI and data platforms.
---
## Partner Integrations Overview
Learn about the Qdrant ecosystem and integration strategies.
[**➡️ Partner Integrations**](/partners/)
---
## Choose Your Integrati... | [
0.03602364659309387,
-0.032501209527254105,
-0.07624591886997223,
-0.006115552503615618,
0.07890361547470093,
-0.051918935030698776,
0.03499995544552803,
0.056377556174993515,
0.06287379562854767,
-0.018449876457452774,
0.005530266091227531,
0.012027965858578682,
0.01845462992787361,
-0.05... | |
7f729989-78f9-5fdb-aa78-cebfa499688f | /course/essentials/day-7/haystack/ | Integrating with Haystack | Haystack Movie Recommendation Assistant > Core Architecture | course | false | Integrating with Haystack > Haystack Movie Recommendation Assistant > Core Architecture
The Haystack recommendation system uses a multi-layered approach to deliver accurate and relevant results:
- **Sparse Vector Search**: Utilizes sparse embeddings to capture keyword-based relevance and semantic meaning
- **Metadata... | [
0.0350322462618351,
-0.07006990164518356,
-0.08256387710571289,
-0.005012631881982088,
0.06984751671552658,
-0.017571309581398964,
0.05041678994894028,
0.012834847904741764,
0.06932198256254196,
0.006714214570820332,
0.03932638093829155,
-0.007899357937276363,
0.05707543343305588,
-0.02359... |
7f73fe9c-68b3-56ed-bd67-ee15fc73d619 | /documentation/tutorials-search-engineering/pdf-retrieval-at-scale/ | Multivector Document Retrieval | Embedding and Mean Pooling | documentation | true | Multivector Document Retrieval > Embedding and Mean Pooling
Simplified version of pooling for **ColPali** model:
(see the full version -- also applicable for **ColQwen** -- in the [tutorial notebook](https://githubtocolab.com/qdrant/examples/blob/master/pdf-retrieval-at-scale/ColPali_ColQwen2_Tutorial.ipynb))
```pyt... | [
0.00794750452041626,
-0.03625708818435669,
-0.04971760883927345,
-0.059796690940856934,
0.09018783271312714,
-0.016208700835704803,
0.05439890921115875,
0.0482734851539135,
0.052354034036397934,
-0.0010640067048370838,
0.028996145352721214,
-0.0042651197873055935,
0.06949643045663834,
-0.0... |
7f7d15f4-41eb-5f98-b850-fdf21b6f90db | /course/essentials/day-2/filterable-hnsw/ | Combining Vector Search and Filtering | Qdrant's Solution: Filterable HNSW | course | false | Combining Vector Search and Filtering > Qdrant's Solution: Filterable HNSW
Qdrant solves this with a smarter approach. We guarantee that the HNSW graph remains connected by creating additional edges to maintain connectivity under filtering. Qdrant builds subgraphs per payload value, then merges them back into the full... | [
0.04053382948040962,
-0.06859361380338669,
-0.053335901349782944,
-0.006064454559236765,
0.0639597550034523,
-0.021117541939020157,
0.0881669819355011,
0.04781513661146164,
0.02661663480103016,
-0.013380135409533978,
0.045142196118831635,
0.033080365508794785,
0.08296654373407364,
0.008964... |
7fa96b4c-901c-5a60-a2ba-0be9b0cc652b | /documentation/search-precision/reranking-semantic-search/ | Reranking for Better Search | Implementing Vector Search with Reranking > Implementation > Vector Search | documentation | false | Reranking for Better Search > Implementing Vector Search with Reranking > Implementation > Vector Search
| **ID** | **Document** | **Score** |
| --- | --- | --- |
| 0 | In machine learning, feature scaling is the process of normalizing the range of... | 0.81 |
| 1 | Feature scaling is commonly used in data preprocessi... | [
0.03278479725122452,
-0.03298524394631386,
-0.05553658679127693,
-0.04400453716516495,
0.08045707643032074,
-0.03685541823506355,
0.04917687177658081,
0.044714100658893585,
0.11361780017614365,
-0.005174824967980385,
-0.0019195619970560074,
0.00031401010346598923,
0.046909213066101074,
-0.... |
7fcdde56-404c-5b9f-bcbb-c07837de27f9 | /documentation/tutorials-search-engineering/food-discovery-recommendations/ | Multimodal Food Search Demo | The dataset | documentation | true | Multimodal Food Search Demo > The dataset
The demo is based on the [Wolt](https://wolt.com/) dataset. It contains over 2M images of dishes from different restaurants along with some additional metadata.
This is how a payload for a single dish looks like (long values are shortened):
```json
{
"cafe": {
"a... | [
0.02675296552479267,
-0.016118641942739487,
-0.06584540009498596,
-0.023963430896401405,
0.10108470171689987,
-0.03413950651884079,
0.07012579590082169,
0.05381200835108757,
0.0677664577960968,
-0.03940528631210327,
0.05389838293194771,
0.0007753109675832093,
0.09325087815523148,
-0.051458... |
7fde1478-8b70-5490-927f-a7ffd5c5ed19 | /course/beginners/module-5/knowledge-check/ | Knowledge Check | course | false | Knowledge Check
Module 5
Work through these before you call the capstone done.
Why does the collection use named vectors instead of one collection per modality?
One signal, one point. A single event can carry text and image evidence at the same time, and named vectors keep all of it on that one point, queryable sep... | [
0.045042600482702255,
-0.028461311012506485,
-0.05544786527752876,
-0.028418855741620064,
0.05915234237909317,
-0.026415612548589706,
0.06723367422819138,
0.05738116055727005,
0.04226106032729149,
-0.018182575702667236,
-0.0011326184030622244,
0.029439691454172134,
0.02756413444876671,
-0.... | |
7fe5c7fc-7d61-5c27-b475-3686eb50b04e | /documentation/platforms/vectorize/ | Vectorize.io | documentation | false | Vectorize.io
[Vectorize](https://vectorize.io/) is a SaaS platform that automates data extraction from [several sources](https://docs.vectorize.io/integrations/source-connectors) and lets you quickly deploy real-time RAG pipelines for your unstructured data. It also includes evaluation to help figure out the best stra... | [
0.029217928647994995,
-0.03320171684026718,
-0.03947218134999275,
-0.04826097935438156,
0.04388992115855217,
-0.019928911700844765,
0.0803816020488739,
0.023249445483088493,
0.04753240942955017,
-0.040377501398324966,
0.005802083760499954,
0.018590763211250305,
0.05445428565144539,
-0.0503... | |
802cb341-0819-50be-b191-f9d06f19eec2 | /course/essentials/day-4/what-is-quantization/ | Vector Quantization Methods | Product Quantization | course | true | Vector Quantization Methods > Product Quantization
[Product quantization](/articles/product-quantization/) employs a divide-and-conquer approach, segmenting vectors into sub-vectors and encoding each segment using learned codebooks. The algorithm splits a high-dimensional vector into equal-sized sub-vectors, then appl... | [
0.05563019588589668,
-0.040917422622442245,
-0.05582230165600777,
-0.061049047857522964,
0.038474492728710175,
-0.010461896657943726,
0.05011553689837456,
0.037841152399778366,
0.09775887429714203,
-0.010784834623336792,
0.0197818111628294,
0.003668722929432988,
0.05281868949532509,
-0.033... |
802f2c5e-66f5-5540-9aba-1b948817b4d3 | /course/beginners/module-4/from-results-to-an-answer/ | From Results to an Answer | course | false | From Results to an Answer
Module 4
Everything so far returns a ranked list. **Retrieval-Augmented Generation (RAG)** sends that list to a language model, which writes an answer from the retrieved results. Generation sits outside the search system.

| Field | Description | Default | Validation |
| --- | --- | --- | --- |
| `id` _string_ | The unique identifier of the entity (in UUID format). | ... | [
0.06858127564191818,
-0.024604469537734985,
-0.006143169477581978,
-0.04104424640536308,
0.05315554514527321,
-0.051841530948877335,
0.021368373185396194,
0.08100301772356033,
0.07932046800851822,
-0.06399513781070709,
0.060733549296855927,
0.01602201908826828,
0.03545614331960678,
-0.0086... |
804f5edd-a5ab-5fdb-be41-0db0428d5a42 | /course/multi-vector-search/module-3/muvera/ | MUVERA | MUVERA: Making Multi-Vector Search Fast | course | false | MUVERA > MUVERA: Making Multi-Vector Search Fast
MUVERA (Multi-Vector Retrieval Algorithm) solves this incompatibility by creating a **single approximation vector** for each document that HNSW can efficiently index. The algorithm works in three stages:
1. **SimHash Clustering**: Groups token vectors into spatial regi... | [
0.07022417336702347,
-0.04813586547970772,
-0.063676618039608,
-0.06816446036100388,
0.08481483906507492,
-0.0013544227695092559,
0.04853985831141472,
0.000649434863589704,
0.06180628016591072,
0.015418145805597305,
0.011890240013599396,
0.0471963956952095,
0.05400674045085907,
-0.03511049... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.