Skip to main content
Glama
io.github.avaazquezz/mcp-qdrant

io.github.avaazquezz/mcp-qdrant

by avaazquezz

Query Qdrant

qdrant_query
Read-onlyIdempotent

Query a Qdrant collection with vector, text, BM25 or hybrid search; fuse and rerank results, apply MMR diversity, payload formulas, field ordering, or random sampling.

Instructions

Search a collection with Qdrant's unified Query API: vector similarity, hybrid fusion, multi-stage reranking, MMR diversity, payload-based score formulas, ordering by a payload field, or random sampling.

    Exactly one query mode is required:
    - `query_vector` — nearest points to a dense vector, a multivector (list
      of vectors), a sparse vector (`{"indices": [...], "values": [...]}`),
      or a point id whose stored vector is reused (that point itself is left
      out of the results). It must match the vector
      selected with `using`. Add `mmr` (`diversity` 0..1,
      `candidates_limit`) to re-order the nearest candidates for diversity:
      set `candidates_limit` well above `limit` (it defaults to `limit`,
      which leaves MMR nothing to choose from). `offset` pages through the
      MMR ranking on Qdrant 1.20 (verified; older servers applied it inside
      the `limit` re-ranked results, so raise `limit` there instead).
    - `query_text` — semantic search with plain text: embedded with the model
      the collection declares for the vector in `using` (`using` can be
      omitted when it declares exactly one). Needs the `embeddings` extra;
      `mmr` works as with `query_vector`.
    - `bm25_query` — keyword search ranked by BM25 (Qdrant 1.20): `using` is
      a payload field whose `text` index has `scoring` set (defaults to the
      collection's declared text field). The index's own tokenizer, stemmer
      and stopwords apply. Needs no embeddings.
    - `fusion` + 2+ `prefetch` stages — combine retrieval strategies:
      `"rrf"` (Reciprocal Rank Fusion), `"dbsf"` (Distribution-Based Score
      Fusion), or `{"method": "rrf", "weights": [2, 1], "k": 60}` for RRF
      with one weight per stage (a count that doesn't match the stages is
      rejected by Qdrant).
    - `formula` — rescore the results of `prefetch` stages (required: a
      formula without prefetch is rejected). `{"expression": ..., "defaults":
      {...}}`. An expression is a number; a variable (`"$score"` is the
      prefetch score, any other string is a payload key); a payload
      condition (e.g. `{"key": "city", "match": {"value": "sf"}}`, worth 1
      if it matches, else 0); or exactly one operator object: `{"sum":
      [...]}`, `{"mult": [...]}`, `{"neg": e}`, `{"abs": e}`, `{"div":
      {"left": e, "right": e}}`, `{"sqrt": e}`, `{"pow": {"base": e,
      "exponent": e}}`, `{"exp": e}`, `{"ln": e}`, `{"log10": e}`,
      `{"geo_distance": {"origin": {"lat": .., "lon": ..}, "to":
      "payload.key"}}`, `{"datetime": "2026-01-01T00:00:00Z"}`,
      `{"datetime_key": "payload.key"}`, and the decays `{"exp_decay" |
      "gauss_decay" | "lin_decay": {"x": e, "target": e, "scale": number,
      "midpoint": number}}`. A payload key a point lacks needs a value in
      `defaults`, or Qdrant rejects the query.
    - `order_by` — sort by a payload field instead of by similarity: a key
      or `{"key": ..., "direction": "asc"|"desc", "start_from": value}`.
      The key needs a payload range index (integer, float or datetime).
    - `sample: "random"` — random points.

    A `prefetch` stage is itself a `query_vector`, `query_text` or
    `bm25_query` query, or a `fusion` of its own nested `prefetch` stages,
    so pipelines nest: fuse semantic + BM25 in one stage, then rerank. `using` selects a named
    vector; `lookup_from` resolves `query_vector` from a point id in
    another collection.

    Results: `with_payload` takes `true`/`false` or a list of keys to return
    only those (e.g. `["title", "url"]`, nested ones as `"meta.author"`) —
    most of what you read back is payload.

    Tuning: `search_params` (`hnsw_ef`, `exact` for brute force,
    `quantization`: `ignore`/`rescore`/`oversampling`, `indexed_only`,
    `acorn`), `score_threshold` (drop weaker hits), `limit` + `offset`
    (paging; `limit` is capped per call by the server's QDRANT_MCP_MAX_LIMIT,
    1000 by default — page with `offset` for more), `timeout_seconds`
    (server-side), and `consistency` (a replica count, or
    `"majority"`/`"quorum"`/`"all"`; only meaningful on a replicated
    deployment). Fails with a clear error if the collection doesn't exist.

    Example (plain): {"collection_name": "docs", "query_vector": [0.1, 0.2, 0.3, 0.4],
        "limit": 5}
    Example (by text): {"collection_name": "docs", "query_text": "housing grants", "limit": 5}
    Example (semantic + BM25): {"collection_name": "docs", "fusion": "rrf", "prefetch": [
        {"query_text": "housing grants", "limit": 20},
        {"bm25_query": "housing grants", "limit": 20}
    ], "limit": 5}
    Example (hybrid): {"collection_name": "docs", "fusion": "rrf", "prefetch": [
        {"query_vector": [0.1, 0.2, 0.3, 0.4], "using": "dense", "limit": 20},
        {"query_vector": {"indices": [1, 7], "values": [0.5, 0.2]}, "using": "sparse",
            "limit": 20}
    ], "limit": 5}
    Example (diverse results): {"collection_name": "docs", "query_vector": [0.1, 0.2, 0.3, 0.4],
        "mmr": {"diversity": 0.5, "candidates_limit": 50}, "limit": 5}
    Example (boost one city): {"collection_name": "docs", "prefetch": [
        {"query_vector": [0.1, 0.2, 0.3, 0.4], "limit": 50}
    ], "formula": {"expression": {"sum": ["$score",
        {"mult": [0.5, {"key": "city", "match": {"value": "sf"}}]}]}}, "limit": 5}
    Example (cheapest first): {"collection_name": "docs", "order_by": {"key": "price",
        "direction": "asc"}, "limit": 5}
    

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "collection_name": "<collection_name>"
    },
    "name": "qdrant_query"
  }
}

Input Schema

NameRequiredDescriptionDefault
mmrNo
limitNo
usingNo
fusionNo
offsetNo
sampleNo
formulaNo
order_byNo
prefetchNo
bm25_queryNo
query_textNo
consistencyNo
lookup_fromNo
query_filterNo
query_vectorNo
with_payloadNo
with_vectorsNo
search_paramsNo
collection_nameYes
score_thresholdNo
timeout_secondsNo

Output Schema

NameRequiredDescriptionDefault
pointsYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed29 schema fields changedv2.12.0
    • removedInput schema / $defs / FormulaInput / properties / defaults / title
      Removed value: -"Defaults"
    • removedInput schema / $defs / FormulaInput / properties / expression / title
      Removed value: -"Expression"
    • removedInput schema / $defs / FormulaInput / title
      Removed value: -"FormulaInput"
    • removedInput schema / $defs / LookupFromInput / properties / collection / title
      Removed value: -"Collection"
    • removedInput schema / $defs / LookupFromInput / properties / vector / title
      Removed value: -"Vector"
    • removedInput schema / $defs / LookupFromInput / title
      Removed value: -"LookupFromInput"
    • removedInput schema / $defs / MmrInput / properties / candidates_limit / title
      Removed value: -"Candidates Limit"
    • removedInput schema / $defs / MmrInput / properties / diversity / title
      Removed value: -"Diversity"
    • removedInput schema / $defs / MmrInput / title
      Removed value: -"MmrInput"
    • changedInput schema / $defs / PrefetchInput / description
      Previous value: -"One prefetch stage: an independent query narrowing candidates before\nthe outer query reranks or fuses them. A stage is either a vector query\n(`query_vector`) or a fusion of its own nested `prefetch` stages\n(`fusion`) — exactly one — which makes multi-stage pipelines possible,\ne.g. fuse dense+sparse, then rerank with a multivector."New value: +"One prefetch stage: an independent query narrowing candidates before\nthe outer query reranks or fuses them. A stage is exactly one of a vector\nquery (`query_vector`), a text query embedded with the collection's\ndeclared model (`query_text`), a BM25 query over a text-indexed payload\nfield (`bm25_query`), or a fusion of its own nested `prefetch` stages\n(`fusion`) — which makes multi-stage pipelines possible, e.g. fuse\nsemantic + BM25, then rerank with a multivector."
    • addedInput schema / $defs / PrefetchInput / properties / bm25_query
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • removedInput schema / $defs / PrefetchInput / properties / fusion / title
      Removed value: -"Fusion"
    • removedInput schema / $defs / PrefetchInput / properties / limit / title
      Removed value: -"Limit"
    • removedInput schema / $defs / PrefetchInput / properties / prefetch / title
      Removed value: -"Prefetch"
    • changedInput schema / $defs / PrefetchInput / properties / query_filter / anyOf
      Previous value: -[
      -  {
      -    "additionalProperties": false,
      -    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      -    "properties": {
      -      "min_should": {
      -        "anyOf": [
      -          {
      -            "properties": {
      -              "conditions": {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              "min_count": {
      -                "type": "integer"
      -              }
      -            },
      -            "required": [
      -              "conditions",
      -              "min_count"
      -            ],
      -            "type": "object"
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "must": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "must_not": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "should": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      }
      -    },
      -    "type": "object"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "additionalProperties": false,
      +    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}, {\"substring\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      +    "properties": {
      +      "min_should": {
      +        "anyOf": [
      +          {
      +            "properties": {
      +              "conditions": {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              "min_count": {
      +                "type": "integer"
      +              }
      +            },
      +            "required": [
      +              "conditions",
      +              "min_count"
      +            ],
      +            "type": "object"
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must_not": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "should": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      }
      +    },
      +    "type": "object"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / $defs / PrefetchInput / properties / query_text
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • removedInput schema / $defs / PrefetchInput / properties / query_vector / title
      Removed value: -"Query Vector"
    • removedInput schema / $defs / PrefetchInput / properties / score_threshold / title
      Removed value: -"Score Threshold"
    • removedInput schema / $defs / PrefetchInput / properties / using / title
      Removed value: -"Using"
    • removedInput schema / $defs / PrefetchInput / title
      Removed value: -"PrefetchInput"
    • removedInput schema / $defs / WeightedRrfInput / properties / k / title
      Removed value: -"K"
    • removedInput schema / $defs / WeightedRrfInput / properties / method / title
      Removed value: -"Method"
    • removedInput schema / $defs / WeightedRrfInput / properties / weights / title
      Removed value: -"Weights"
    • removedInput schema / $defs / WeightedRrfInput / title
      Removed value: -"WeightedRrfInput"
    • addedInput schema / properties / bm25_query
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Bm25 Query"
      +}
    • changedInput schema / properties / query_filter / anyOf
      Previous value: -[
      -  {
      -    "additionalProperties": false,
      -    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      -    "properties": {
      -      "min_should": {
      -        "anyOf": [
      -          {
      -            "properties": {
      -              "conditions": {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              "min_count": {
      -                "type": "integer"
      -              }
      -            },
      -            "required": [
      -              "conditions",
      -              "min_count"
      -            ],
      -            "type": "object"
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "must": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "must_not": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      },
      -      "should": {
      -        "anyOf": [
      -          {
      -            "anyOf": [
      -              {
      -                "items": {
      -                  "type": "object"
      -                },
      -                "type": "array"
      -              },
      -              {
      -                "type": "object"
      -              }
      -            ]
      -          },
      -          {
      -            "type": "null"
      -          }
      -        ]
      -      }
      -    },
      -    "type": "object"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "additionalProperties": false,
      +    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}, {\"substring\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      +    "properties": {
      +      "min_should": {
      +        "anyOf": [
      +          {
      +            "properties": {
      +              "conditions": {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              "min_count": {
      +                "type": "integer"
      +              }
      +            },
      +            "required": [
      +              "conditions",
      +              "min_count"
      +            ],
      +            "type": "object"
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must_not": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "should": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      }
      +    },
      +    "type": "object"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / properties / query_text
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Query Text"
      +}
    • addedInput schema / properties / with_payload / anyOf
      Added value: +[
      +  {
      +    "type": "boolean"
      +  },
      +  {
      +    "items": {
      +      "type": "string"
      +    },
      +    "minItems": 1,
      +    "type": "array"
      +  }
      +]
    • removedInput schema / properties / with_payload / type
      Removed value: -"boolean"
  2. Changed56 schema fields changedv2.6.0
    • removedInput schema / $defs / DatetimeRange
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Range filter request",
      -  "properties": {
      -    "gt": {
      -      "anyOf": [
      -        {
      -          "format": "date-time",
      -          "type": "string"
      -        },
      -        {
      -          "format": "date",
      -          "type": "string"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &gt; range.gt",
      -      "title": "Gt"
      -    },
      -    "gte": {
      -      "anyOf": [
      -        {
      -          "format": "date-time",
      -          "type": "string"
      -        },
      -        {
      -          "format": "date",
      -          "type": "string"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &gt;= range.gte",
      -      "title": "Gte"
      -    },
      -    "lt": {
      -      "anyOf": [
      -        {
      -          "format": "date-time",
      -          "type": "string"
      -        },
      -        {
      -          "format": "date",
      -          "type": "string"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &lt; range.lt",
      -      "title": "Lt"
      -    },
      -    "lte": {
      -      "anyOf": [
      -        {
      -          "format": "date-time",
      -          "type": "string"
      -        },
      -        {
      -          "format": "date",
      -          "type": "string"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &lt;= range.lte",
      -      "title": "Lte"
      -    }
      -  },
      -  "title": "DatetimeRange",
      -  "type": "object"
      -}
    • addedInput schema / $defs / Direction
      Added value: +{
      +  "enum": [
      +    "asc",
      +    "desc"
      +  ],
      +  "title": "Direction",
      +  "type": "string"
      +}
    • removedInput schema / $defs / FieldCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "All possible payload filtering conditions",
      -  "properties": {
      -    "geo_bounding_box": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/GeoBoundingBox"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check if points geolocation lies in a given area"
      -    },
      -    "geo_polygon": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/GeoPolygon"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check if geo point is within a given polygon"
      -    },
      -    "geo_radius": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/GeoRadius"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check if geo point is within a given radius"
      -    },
      -    "is_empty": {
      -      "anyOf": [
      -        {
      -          "type": "boolean"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check that the field is empty, alternative syntax for `is_empty: 'field_name'`",
      -      "title": "Is Empty"
      -    },
      -    "is_null": {
      -      "anyOf": [
      -        {
      -          "type": "boolean"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check that the field is null, alternative syntax for `is_null: 'field_name'`",
      -      "title": "Is Null"
      -    },
      -    "key": {
      -      "description": "Payload key",
      -      "title": "Key",
      -      "type": "string"
      -    },
      -    "match": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/MatchValue"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchText"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchTextAny"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchPhrase"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchPrefix"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchAny"
      -        },
      -        {
      -          "$ref": "#/$defs/MatchExcept"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check if point has field with a given value",
      -      "title": "Match"
      -    },
      -    "range": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/Range"
      -        },
      -        {
      -          "$ref": "#/$defs/DatetimeRange"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check if points value lies in a given range",
      -      "title": "Range"
      -    },
      -    "values_count": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/ValuesCount"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Check number of values of the field"
      -    }
      -  },
      -  "required": [
      -    "key"
      -  ],
      -  "title": "FieldCondition",
      -  "type": "object"
      -}
    • removedInput schema / $defs / Filter
      Removed value: -{
      -  "additionalProperties": false,
      -  "properties": {
      -    "min_should": {
      -      "anyOf": [
      -        {
      -          "$ref": "#/$defs/MinShould"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "At least minimum amount of given conditions should match"
      -    },
      -    "must": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "anyOf": [
      -              {
      -                "$ref": "#/$defs/FieldCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsEmptyCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsNullCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasIdCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasVectorCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/SliceCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/NestedCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/Filter"
      -              }
      -            ]
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "$ref": "#/$defs/FieldCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsEmptyCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsNullCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasIdCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasVectorCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/SliceCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/NestedCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/Filter"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "All conditions must match",
      -      "title": "Must"
      -    },
      -    "must_not": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "anyOf": [
      -              {
      -                "$ref": "#/$defs/FieldCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsEmptyCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsNullCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasIdCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasVectorCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/SliceCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/NestedCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/Filter"
      -              }
      -            ]
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "$ref": "#/$defs/FieldCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsEmptyCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsNullCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasIdCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasVectorCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/SliceCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/NestedCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/Filter"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "All conditions must NOT match",
      -      "title": "Must Not"
      -    },
      -    "should": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "anyOf": [
      -              {
      -                "$ref": "#/$defs/FieldCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsEmptyCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/IsNullCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasIdCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/HasVectorCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/SliceCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/NestedCondition"
      -              },
      -              {
      -                "$ref": "#/$defs/Filter"
      -              }
      -            ]
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "$ref": "#/$defs/FieldCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsEmptyCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/IsNullCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasIdCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/HasVectorCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/SliceCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/NestedCondition"
      -        },
      -        {
      -          "$ref": "#/$defs/Filter"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "At least one of those conditions should match",
      -      "title": "Should"
      -    }
      -  },
      -  "title": "Filter",
      -  "type": "object"
      -}
    • addedInput schema / $defs / FormulaInput
      Added value: +{
      +  "additionalProperties": false,
      +  "description": "A custom scoring formula applied over the results of `prefetch` stages.\n`expression` is typed loosely on purpose (the full grammar is a 35 KB\nrecursive schema that would bloat every tool listing); it is validated\nserver-side and the grammar is documented on `qdrant_query`. `defaults`\nsupplies a value for payload keys a point doesn't have.",
      +  "properties": {
      +    "defaults": {
      +      "anyOf": [
      +        {
      +          "additionalProperties": true,
      +          "type": "object"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "title": "Defaults"
      +    },
      +    "expression": {
      +      "anyOf": [
      +        {
      +          "additionalProperties": true,
      +          "type": "object"
      +        },
      +        {
      +          "type": "number"
      +        },
      +        {
      +          "type": "string"
      +        }
      +      ],
      +      "title": "Expression"
      +    }
      +  },
      +  "required": [
      +    "expression"
      +  ],
      +  "title": "FormulaInput",
      +  "type": "object"
      +}
    • removedInput schema / $defs / GeoBoundingBox
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Geo filter request  Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges",
      -  "properties": {
      -    "bottom_right": {
      -      "$ref": "#/$defs/GeoPoint",
      -      "description": "Geo filter request  Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges"
      -    },
      -    "top_left": {
      -      "$ref": "#/$defs/GeoPoint",
      -      "description": "Geo filter request  Matches coordinates inside the rectangle, described by coordinates of lop-left and bottom-right edges"
      -    }
      -  },
      -  "required": [
      -    "top_left",
      -    "bottom_right"
      -  ],
      -  "title": "GeoBoundingBox",
      -  "type": "object"
      -}
    • removedInput schema / $defs / GeoLineString
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Ordered sequence of GeoPoints representing the line",
      -  "properties": {
      -    "points": {
      -      "description": "Ordered sequence of GeoPoints representing the line",
      -      "items": {
      -        "$ref": "#/$defs/GeoPoint"
      -      },
      -      "title": "Points",
      -      "type": "array"
      -    }
      -  },
      -  "required": [
      -    "points"
      -  ],
      -  "title": "GeoLineString",
      -  "type": "object"
      -}
    • removedInput schema / $defs / GeoPoint
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Geo point payload schema",
      -  "properties": {
      -    "lat": {
      -      "description": "Geo point payload schema",
      -      "title": "Lat",
      -      "type": "number"
      -    },
      -    "lon": {
      -      "description": "Geo point payload schema",
      -      "title": "Lon",
      -      "type": "number"
      -    }
      -  },
      -  "required": [
      -    "lon",
      -    "lat"
      -  ],
      -  "title": "GeoPoint",
      -  "type": "object"
      -}
    • removedInput schema / $defs / GeoPolygon
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Geo filter request  Matches coordinates inside the polygon, defined by `exterior` and `interiors`",
      -  "properties": {
      -    "exterior": {
      -      "$ref": "#/$defs/GeoLineString",
      -      "description": "Geo filter request  Matches coordinates inside the polygon, defined by `exterior` and `interiors`"
      -    },
      -    "interiors": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "$ref": "#/$defs/GeoLineString"
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "Interior lines (if present) bound holes within the surface each GeoLineString must consist of a minimum of 4 points, and the first and last points must be the same.",
      -      "title": "Interiors"
      -    }
      -  },
      -  "required": [
      -    "exterior"
      -  ],
      -  "title": "GeoPolygon",
      -  "type": "object"
      -}
    • removedInput schema / $defs / GeoRadius
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Geo filter request  Matches coordinates inside the circle of `radius` and center with coordinates `center`",
      -  "properties": {
      -    "center": {
      -      "$ref": "#/$defs/GeoPoint",
      -      "description": "Geo filter request  Matches coordinates inside the circle of `radius` and center with coordinates `center`"
      -    },
      -    "radius": {
      -      "description": "Radius of the area in meters",
      -      "title": "Radius",
      -      "type": "number"
      -    }
      -  },
      -  "required": [
      -    "center",
      -    "radius"
      -  ],
      -  "title": "GeoRadius",
      -  "type": "object"
      -}
    • removedInput schema / $defs / HasIdCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "ID-based filtering condition",
      -  "properties": {
      -    "has_id": {
      -      "description": "ID-based filtering condition",
      -      "items": {
      -        "anyOf": [
      -          {
      -            "type": "integer"
      -          },
      -          {
      -            "type": "string"
      -          },
      -          {
      -            "format": "uuid",
      -            "type": "string"
      -          }
      -        ]
      -      },
      -      "title": "Has Id",
      -      "type": "array"
      -    }
      -  },
      -  "required": [
      -    "has_id"
      -  ],
      -  "title": "HasIdCondition",
      -  "type": "object"
      -}
    • removedInput schema / $defs / HasVectorCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Filter points which have specific vector assigned",
      -  "properties": {
      -    "has_vector": {
      -      "description": "Filter points which have specific vector assigned",
      -      "title": "Has Vector",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "has_vector"
      -  ],
      -  "title": "HasVectorCondition",
      -  "type": "object"
      -}
    • removedInput schema / $defs / IsEmptyCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Select points with empty payload for a specified field",
      -  "properties": {
      -    "is_empty": {
      -      "$ref": "#/$defs/PayloadField",
      -      "description": "Select points with empty payload for a specified field"
      -    }
      -  },
      -  "required": [
      -    "is_empty"
      -  ],
      -  "title": "IsEmptyCondition",
      -  "type": "object"
      -}
    • removedInput schema / $defs / IsNullCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Select points with null payload for a specified field",
      -  "properties": {
      -    "is_null": {
      -      "$ref": "#/$defs/PayloadField",
      -      "description": "Select points with null payload for a specified field"
      -    }
      -  },
      -  "required": [
      -    "is_null"
      -  ],
      -  "title": "IsNullCondition",
      -  "type": "object"
      -}
    • addedInput schema / $defs / LookupFromInput / additionalProperties
      Added value: +false
    • removedInput schema / $defs / MatchAny
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Exact match on any of the given values",
      -  "properties": {
      -    "any": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "type": "string"
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "items": {
      -            "type": "integer"
      -          },
      -          "type": "array"
      -        }
      -      ],
      -      "description": "Exact match on any of the given values",
      -      "title": "Any"
      -    }
      -  },
      -  "required": [
      -    "any"
      -  ],
      -  "title": "MatchAny",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchExcept
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Should have at least one value not matching the any given values",
      -  "properties": {
      -    "except": {
      -      "anyOf": [
      -        {
      -          "items": {
      -            "type": "string"
      -          },
      -          "type": "array"
      -        },
      -        {
      -          "items": {
      -            "type": "integer"
      -          },
      -          "type": "array"
      -        }
      -      ],
      -      "description": "Should have at least one value not matching the any given values",
      -      "title": "Except"
      -    }
      -  },
      -  "required": [
      -    "except"
      -  ],
      -  "title": "MatchExcept",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchPhrase
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Full-text phrase match of the string.",
      -  "properties": {
      -    "phrase": {
      -      "description": "Full-text phrase match of the string.",
      -      "title": "Phrase",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "phrase"
      -  ],
      -  "title": "MatchPhrase",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchPrefix
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Match keyword values that start with the given string.  Byte-wise (hence, for valid UTF-8, character-wise) and case-sensitive, consistent with exact keyword matching. Served efficiently by a keyword index created with the `prefix` option.",
      -  "properties": {
      -    "prefix": {
      -      "description": "Match keyword values that start with the given string.  Byte-wise (hence, for valid UTF-8, character-wise) and case-sensitive, consistent with exact keyword matching. Served efficiently by a keyword index created with the `prefix` option.",
      -      "title": "Prefix",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "prefix"
      -  ],
      -  "title": "MatchPrefix",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchText
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Full-text match of the strings.",
      -  "properties": {
      -    "text": {
      -      "description": "Full-text match of the strings.",
      -      "title": "Text",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "text"
      -  ],
      -  "title": "MatchText",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchTextAny
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Full-text match of at least one token of the string.",
      -  "properties": {
      -    "text_any": {
      -      "description": "Full-text match of at least one token of the string.",
      -      "title": "Text Any",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "text_any"
      -  ],
      -  "title": "MatchTextAny",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MatchValue
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Exact match of the given value",
      -  "properties": {
      -    "value": {
      -      "anyOf": [
      -        {
      -          "type": "boolean"
      -        },
      -        {
      -          "type": "integer"
      -        },
      -        {
      -          "type": "string"
      -        }
      -      ],
      -      "description": "Exact match of the given value",
      -      "title": "Value"
      -    }
      -  },
      -  "required": [
      -    "value"
      -  ],
      -  "title": "MatchValue",
      -  "type": "object"
      -}
    • removedInput schema / $defs / MinShould
      Removed value: -{
      -  "additionalProperties": false,
      -  "properties": {
      -    "conditions": {
      -      "description": "",
      -      "items": {
      -        "anyOf": [
      -          {
      -            "$ref": "#/$defs/FieldCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/IsEmptyCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/IsNullCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/HasIdCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/HasVectorCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/SliceCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/NestedCondition"
      -          },
      -          {
      -            "$ref": "#/$defs/Filter"
      -          }
      -        ]
      -      },
      -      "title": "Conditions",
      -      "type": "array"
      -    },
      -    "min_count": {
      -      "description": "",
      -      "title": "Min Count",
      -      "type": "integer"
      -    }
      -  },
      -  "required": [
      -    "conditions",
      -    "min_count"
      -  ],
      -  "title": "MinShould",
      -  "type": "object"
      -}
    • addedInput schema / $defs / MmrInput
      Added value: +{
      +  "additionalProperties": false,
      +  "description": "Maximal Marginal Relevance: re-orders the nearest candidates to trade\nrelevance for diversity. `diversity` runs 0 (pure relevance) to 1 (most\ndiverse). `candidates_limit` is how many nearest candidates it re-ranks; it\ndefaults to the query's `limit`, so MMR has nothing to choose from unless\nyou set it well above `limit` (verified: `limit` 2 without it returns the\nsame two points as a plain query).",
      +  "properties": {
      +    "candidates_limit": {
      +      "anyOf": [
      +        {
      +          "exclusiveMinimum": 0,
      +          "type": "integer"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "title": "Candidates Limit"
      +    },
      +    "diversity": {
      +      "anyOf": [
      +        {
      +          "maximum": 1,
      +          "minimum": 0,
      +          "type": "number"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "title": "Diversity"
      +    }
      +  },
      +  "title": "MmrInput",
      +  "type": "object"
      +}
    • removedInput schema / $defs / Nested
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Select points with payload for a specified nested field",
      -  "properties": {
      -    "filter": {
      -      "$ref": "#/$defs/Filter",
      -      "description": "Select points with payload for a specified nested field"
      -    },
      -    "key": {
      -      "description": "Select points with payload for a specified nested field",
      -      "title": "Key",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "key",
      -    "filter"
      -  ],
      -  "title": "Nested",
      -  "type": "object"
      -}
    • removedInput schema / $defs / NestedCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "properties": {
      -    "nested": {
      -      "$ref": "#/$defs/Nested",
      -      "description": ""
      -    }
      -  },
      -  "required": [
      -    "nested"
      -  ],
      -  "title": "NestedCondition",
      -  "type": "object"
      -}
    • addedInput schema / $defs / OrderBy
      Added value: +{
      +  "additionalProperties": false,
      +  "properties": {
      +    "direction": {
      +      "anyOf": [
      +        {
      +          "$ref": "#/$defs/Direction"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "description": "Direction of ordering: `asc` or `desc`. Default is ascending."
      +    },
      +    "key": {
      +      "description": "Payload key to order by",
      +      "title": "Key",
      +      "type": "string"
      +    },
      +    "start_from": {
      +      "anyOf": [
      +        {
      +          "type": "integer"
      +        },
      +        {
      +          "type": "number"
      +        },
      +        {
      +          "format": "date-time",
      +          "type": "string"
      +        },
      +        {
      +          "format": "date",
      +          "type": "string"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "description": "Which payload value to start scrolling from. Default is the lowest value for `asc` and the highest for `desc`",
      +      "title": "Start From"
      +    }
      +  },
      +  "required": [
      +    "key"
      +  ],
      +  "title": "OrderBy",
      +  "type": "object"
      +}
    • removedInput schema / $defs / PayloadField
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Payload field",
      -  "properties": {
      -    "key": {
      -      "description": "Payload field name",
      -      "title": "Key",
      -      "type": "string"
      -    }
      -  },
      -  "required": [
      -    "key"
      -  ],
      -  "title": "PayloadField",
      -  "type": "object"
      -}
    • addedInput schema / $defs / PrefetchInput / additionalProperties
      Added value: +false
    • changedInput schema / $defs / PrefetchInput / description
      Previous value: -"One prefetch stage: an independent query narrowing candidates before\nthe outer query reranks or fuses them. One level only — Qdrant allows\nnested prefetch, but nothing in this catalog needs it."New value: +"One prefetch stage: an independent query narrowing candidates before\nthe outer query reranks or fuses them. A stage is either a vector query\n(`query_vector`) or a fusion of its own nested `prefetch` stages\n(`fusion`) — exactly one — which makes multi-stage pipelines possible,\ne.g. fuse dense+sparse, then rerank with a multivector."
    • addedInput schema / $defs / PrefetchInput / properties / fusion
      Added value: +{
      +  "anyOf": [
      +    {
      +      "enum": [
      +        "rrf",
      +        "dbsf"
      +      ],
      +      "type": "string"
      +    },
      +    {
      +      "$ref": "#/$defs/WeightedRrfInput"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Fusion"
      +}
    • addedInput schema / $defs / PrefetchInput / properties / prefetch
      Added value: +{
      +  "anyOf": [
      +    {
      +      "items": {
      +        "$ref": "#/$defs/PrefetchInput"
      +      },
      +      "type": "array"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Prefetch"
      +}
    • changedInput schema / $defs / PrefetchInput / properties / query_filter / anyOf
      Previous value: -[
      -  {
      -    "$ref": "#/$defs/Filter"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "additionalProperties": false,
      +    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      +    "properties": {
      +      "min_should": {
      +        "anyOf": [
      +          {
      +            "properties": {
      +              "conditions": {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              "min_count": {
      +                "type": "integer"
      +              }
      +            },
      +            "required": [
      +              "conditions",
      +              "min_count"
      +            ],
      +            "type": "object"
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must_not": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "should": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      }
      +    },
      +    "type": "object"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • changedInput schema / $defs / PrefetchInput / properties / query_vector / anyOf
      Previous value: -[
      -  {
      -    "items": {
      -      "type": "number"
      -    },
      -    "type": "array"
      -  },
      -  {
      -    "type": "integer"
      -  },
      -  {
      -    "type": "string"
      -  }
      -]New value: +[
      +  {
      +    "items": {
      +      "type": "number"
      +    },
      +    "minItems": 1,
      +    "type": "array"
      +  },
      +  {
      +    "items": {
      +      "items": {
      +        "type": "number"
      +      },
      +      "minItems": 1,
      +      "type": "array"
      +    },
      +    "minItems": 1,
      +    "type": "array"
      +  },
      +  {
      +    "$ref": "#/$defs/SparseVector"
      +  },
      +  {
      +    "type": "integer"
      +  },
      +  {
      +    "type": "string"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / $defs / PrefetchInput / properties / query_vector / default
      Added value: +null
    • addedInput schema / $defs / PrefetchInput / properties / score_threshold
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "number"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Score Threshold"
      +}
    • addedInput schema / $defs / PrefetchInput / properties / search_params
      Added value: +{
      +  "anyOf": [
      +    {
      +      "additionalProperties": false,
      +      "description": "Search-time tuning. `hnsw_ef`: beam width of the HNSW search (higher = more accurate, slower). `exact`: skip the index and brute-force. `indexed_only`: search only indexed segments. `quantization`: {ignore, rescore, oversampling} for quantized collections. `acorn`: {enable, max_selectivity} for filtered searches. `idf`: advanced, for sparse-vector IDF scoring (`global`, or an object with a `corpus` filter).",
      +      "properties": {
      +        "acorn": {
      +          "anyOf": [
      +            {
      +              "additionalProperties": false,
      +              "properties": {
      +                "enable": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "max_selectivity": {
      +                  "anyOf": [
      +                    {
      +                      "type": "number"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                }
      +              },
      +              "type": "object"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "exact": {
      +          "anyOf": [
      +            {
      +              "type": "boolean"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "hnsw_ef": {
      +          "anyOf": [
      +            {
      +              "type": "integer"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "idf": {
      +          "anyOf": [
      +            {
      +              "anyOf": [
      +                {
      +                  "enum": [
      +                    "global"
      +                  ],
      +                  "type": "string"
      +                },
      +                {
      +                  "type": "object"
      +                }
      +              ]
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "indexed_only": {
      +          "anyOf": [
      +            {
      +              "type": "boolean"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "quantization": {
      +          "anyOf": [
      +            {
      +              "additionalProperties": false,
      +              "properties": {
      +                "ignore": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "oversampling": {
      +                  "anyOf": [
      +                    {
      +                      "type": "number"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "rescore": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                }
      +              },
      +              "type": "object"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        }
      +      },
      +      "type": "object"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • removedInput schema / $defs / PrefetchInput / required
      Removed value: -[
      -  "query_vector"
      -]
    • removedInput schema / $defs / Range
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Range filter request",
      -  "properties": {
      -    "gt": {
      -      "anyOf": [
      -        {
      -          "type": "number"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &gt; range.gt",
      -      "title": "Gt"
      -    },
      -    "gte": {
      -      "anyOf": [
      -        {
      -          "type": "number"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &gt;= range.gte",
      -      "title": "Gte"
      -    },
      -    "lt": {
      -      "anyOf": [
      -        {
      -          "type": "number"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &lt; range.lt",
      -      "title": "Lt"
      -    },
      -    "lte": {
      -      "anyOf": [
      -        {
      -          "type": "number"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key &lt;= range.lte",
      -      "title": "Lte"
      -    }
      -  },
      -  "title": "Range",
      -  "type": "object"
      -}
    • removedInput schema / $defs / Slice
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "One of `total` disjoint deterministic slices of the id space.  A point belongs to the slice iff `hash(id) % total == index`, where `hash` is SipHash-2-4 with a zero key over the canonical id bytes: 8 little-endian bytes for numeric ids, the 16 RFC 4122 bytes for UUIDs. For a fixed `total`, slices `0..total` are disjoint and together cover all points; membership is uniform regardless of the id scheme and stable across queries, segments, platforms and Qdrant versions.  Slices with different `total` values are correlated (same hash, no salt): e.g. slice `0` of `total: 4` is a strict subset of slice `0` of `total: 2`. This keeps a smaller sample contained in a larger one.",
      -  "properties": {
      -    "index": {
      -      "description": "Which slice to select, must be in `0..total`",
      -      "title": "Index",
      -      "type": "integer"
      -    },
      -    "total": {
      -      "description": "Total number of disjoint slices the id space is split into",
      -      "title": "Total",
      -      "type": "integer"
      -    }
      -  },
      -  "required": [
      -    "total",
      -    "index"
      -  ],
      -  "title": "Slice",
      -  "type": "object"
      -}
    • removedInput schema / $defs / SliceCondition
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Select points that fall into one of `total` disjoint deterministic slices of the id space, for parallel scans and reproducible sampling.",
      -  "properties": {
      -    "slice": {
      -      "$ref": "#/$defs/Slice",
      -      "description": "Select points that fall into one of `total` disjoint deterministic slices of the id space, for parallel scans and reproducible sampling."
      -    }
      -  },
      -  "required": [
      -    "slice"
      -  ],
      -  "title": "SliceCondition",
      -  "type": "object"
      -}
    • addedInput schema / $defs / SparseVector
      Added value: +{
      +  "additionalProperties": false,
      +  "description": "Sparse vector structure",
      +  "properties": {
      +    "indices": {
      +      "description": "Indices must be unique",
      +      "items": {
      +        "type": "integer"
      +      },
      +      "title": "Indices",
      +      "type": "array"
      +    },
      +    "values": {
      +      "description": "Values and indices must be the same length",
      +      "items": {
      +        "type": "number"
      +      },
      +      "title": "Values",
      +      "type": "array"
      +    }
      +  },
      +  "required": [
      +    "indices",
      +    "values"
      +  ],
      +  "title": "SparseVector",
      +  "type": "object"
      +}
    • removedInput schema / $defs / ValuesCount
      Removed value: -{
      -  "additionalProperties": false,
      -  "description": "Values count filter request",
      -  "properties": {
      -    "gt": {
      -      "anyOf": [
      -        {
      -          "type": "integer"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key.length() &gt; values_count.gt",
      -      "title": "Gt"
      -    },
      -    "gte": {
      -      "anyOf": [
      -        {
      -          "type": "integer"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key.length() &gt;= values_count.gte",
      -      "title": "Gte"
      -    },
      -    "lt": {
      -      "anyOf": [
      -        {
      -          "type": "integer"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key.length() &lt; values_count.lt",
      -      "title": "Lt"
      -    },
      -    "lte": {
      -      "anyOf": [
      -        {
      -          "type": "integer"
      -        },
      -        {
      -          "type": "null"
      -        }
      -      ],
      -      "default": null,
      -      "description": "point.key.length() &lt;= values_count.lte",
      -      "title": "Lte"
      -    }
      -  },
      -  "title": "ValuesCount",
      -  "type": "object"
      -}
    • addedInput schema / $defs / WeightedRrfInput
      Added value: +{
      +  "additionalProperties": false,
      +  "description": "Reciprocal Rank Fusion with tuning, instead of the plain `\"rrf\"` name:\n`weights` gives each prefetch stage's ranking a weight (one per stage, in\norder), `k` is the rank-smoothing constant.",
      +  "properties": {
      +    "k": {
      +      "anyOf": [
      +        {
      +          "exclusiveMinimum": 0,
      +          "type": "integer"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "title": "K"
      +    },
      +    "method": {
      +      "const": "rrf",
      +      "default": "rrf",
      +      "title": "Method",
      +      "type": "string"
      +    },
      +    "weights": {
      +      "anyOf": [
      +        {
      +          "items": {
      +            "type": "number"
      +          },
      +          "minItems": 1,
      +          "type": "array"
      +        },
      +        {
      +          "type": "null"
      +        }
      +      ],
      +      "default": null,
      +      "title": "Weights"
      +    }
      +  },
      +  "title": "WeightedRrfInput",
      +  "type": "object"
      +}
    • addedInput schema / properties / consistency
      Added value: +{
      +  "anyOf": [
      +    {
      +      "exclusiveMinimum": 0,
      +      "type": "integer"
      +    },
      +    {
      +      "enum": [
      +        "majority",
      +        "quorum",
      +        "all"
      +      ],
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Consistency"
      +}
    • addedInput schema / properties / formula
      Added value: +{
      +  "anyOf": [
      +    {
      +      "$ref": "#/$defs/FormulaInput"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • changedInput schema / properties / fusion / anyOf
      Previous value: -[
      -  {
      -    "enum": [
      -      "rrf",
      -      "dbsf"
      -    ],
      -    "type": "string"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "enum": [
      +      "rrf",
      +      "dbsf"
      +    ],
      +    "type": "string"
      +  },
      +  {
      +    "$ref": "#/$defs/WeightedRrfInput"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / properties / mmr
      Added value: +{
      +  "anyOf": [
      +    {
      +      "$ref": "#/$defs/MmrInput"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • addedInput schema / properties / offset
      Added value: +{
      +  "anyOf": [
      +    {
      +      "minimum": 0,
      +      "type": "integer"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Offset"
      +}
    • addedInput schema / properties / order_by
      Added value: +{
      +  "anyOf": [
      +    {
      +      "$ref": "#/$defs/OrderBy"
      +    },
      +    {
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Order By"
      +}
    • changedInput schema / properties / query_filter / anyOf
      Previous value: -[
      -  {
      -    "$ref": "#/$defs/Filter"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "additionalProperties": false,
      +    "description": "Qdrant payload filter. Combine conditions with `must` (all hold), `should` (any holds), `must_not` (none holds) or `min_should` ({conditions, min_count}); each takes a list of conditions or a single one. A condition is one of: {\"key\": k, \"match\": M} where M is exactly one of {\"value\": v}, {\"any\": [..]}, {\"except\": [..]}, {\"text\": s}, {\"text_any\": s}, {\"phrase\": s}, {\"prefix\": s}; {\"key\": k, \"range\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": number or datetime}}; {\"key\": k, \"values_count\": {\"lt\"|\"lte\"|\"gt\"|\"gte\": n}}; {\"key\": k, \"geo_radius\": {\"center\": {\"lat\", \"lon\"}, \"radius\": meters}}; {\"key\": k, \"geo_bounding_box\": {\"top_left\", \"bottom_right\"}}; {\"key\": k, \"geo_polygon\": {\"exterior\", \"interiors\"}}; {\"is_empty\": {\"key\": k}}; {\"is_null\": {\"key\": k}}; {\"has_id\": [ids]}; {\"has_vector\": name}; {\"slice\": {\"total\": n, \"index\": i}}; {\"nested\": {\"key\": k, \"filter\": <filter>}}; or a nested filter. Keys for nested objects use dots (`a.b`); objects inside arrays use `a[].b`.",
      +    "properties": {
      +      "min_should": {
      +        "anyOf": [
      +          {
      +            "properties": {
      +              "conditions": {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              "min_count": {
      +                "type": "integer"
      +              }
      +            },
      +            "required": [
      +              "conditions",
      +              "min_count"
      +            ],
      +            "type": "object"
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "must_not": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      },
      +      "should": {
      +        "anyOf": [
      +          {
      +            "anyOf": [
      +              {
      +                "items": {
      +                  "type": "object"
      +                },
      +                "type": "array"
      +              },
      +              {
      +                "type": "object"
      +              }
      +            ]
      +          },
      +          {
      +            "type": "null"
      +          }
      +        ]
      +      }
      +    },
      +    "type": "object"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • changedInput schema / properties / query_vector / anyOf
      Previous value: -[
      -  {
      -    "items": {
      -      "type": "number"
      -    },
      -    "minItems": 1,
      -    "type": "array"
      -  },
      -  {
      -    "type": "integer"
      -  },
      -  {
      -    "type": "string"
      -  },
      -  {
      -    "type": "null"
      -  }
      -]New value: +[
      +  {
      +    "items": {
      +      "type": "number"
      +    },
      +    "minItems": 1,
      +    "type": "array"
      +  },
      +  {
      +    "items": {
      +      "items": {
      +        "type": "number"
      +      },
      +      "minItems": 1,
      +      "type": "array"
      +    },
      +    "minItems": 1,
      +    "type": "array"
      +  },
      +  {
      +    "$ref": "#/$defs/SparseVector"
      +  },
      +  {
      +    "type": "integer"
      +  },
      +  {
      +    "type": "string"
      +  },
      +  {
      +    "type": "null"
      +  }
      +]
    • addedInput schema / properties / sample
      Added value: +{
      +  "anyOf": [
      +    {
      +      "const": "random",
      +      "type": "string"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Sample"
      +}
    • addedInput schema / properties / score_threshold
      Added value: +{
      +  "anyOf": [
      +    {
      +      "type": "number"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Score Threshold"
      +}
    • addedInput schema / properties / search_params
      Added value: +{
      +  "anyOf": [
      +    {
      +      "additionalProperties": false,
      +      "description": "Search-time tuning. `hnsw_ef`: beam width of the HNSW search (higher = more accurate, slower). `exact`: skip the index and brute-force. `indexed_only`: search only indexed segments. `quantization`: {ignore, rescore, oversampling} for quantized collections. `acorn`: {enable, max_selectivity} for filtered searches. `idf`: advanced, for sparse-vector IDF scoring (`global`, or an object with a `corpus` filter).",
      +      "properties": {
      +        "acorn": {
      +          "anyOf": [
      +            {
      +              "additionalProperties": false,
      +              "properties": {
      +                "enable": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "max_selectivity": {
      +                  "anyOf": [
      +                    {
      +                      "type": "number"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                }
      +              },
      +              "type": "object"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "exact": {
      +          "anyOf": [
      +            {
      +              "type": "boolean"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "hnsw_ef": {
      +          "anyOf": [
      +            {
      +              "type": "integer"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "idf": {
      +          "anyOf": [
      +            {
      +              "anyOf": [
      +                {
      +                  "enum": [
      +                    "global"
      +                  ],
      +                  "type": "string"
      +                },
      +                {
      +                  "type": "object"
      +                }
      +              ]
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "indexed_only": {
      +          "anyOf": [
      +            {
      +              "type": "boolean"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        },
      +        "quantization": {
      +          "anyOf": [
      +            {
      +              "additionalProperties": false,
      +              "properties": {
      +                "ignore": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "oversampling": {
      +                  "anyOf": [
      +                    {
      +                      "type": "number"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                },
      +                "rescore": {
      +                  "anyOf": [
      +                    {
      +                      "type": "boolean"
      +                    },
      +                    {
      +                      "type": "null"
      +                    }
      +                  ]
      +                }
      +              },
      +              "type": "object"
      +            },
      +            {
      +              "type": "null"
      +            }
      +          ]
      +        }
      +      },
      +      "type": "object"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null
      +}
    • addedInput schema / properties / timeout_seconds
      Added value: +{
      +  "anyOf": [
      +    {
      +      "exclusiveMinimum": 0,
      +      "type": "integer"
      +    },
      +    {
      +      "type": "null"
      +    }
      +  ],
      +  "default": null,
      +  "title": "Timeout Seconds"
      +}
  3. First observedv1.1.1

TDQS

A4.5/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly/idempotent/non-destructive, and the description layers on real behavioral facts beyond them: the server-side limit cap via QDRANT_MCP_MAX_LIMIT (1000), the 1.20 vs. older offset behavior under MMR, defaults that silently neuter MMR, weight-count and prefetch-less-formula rejections, the defaults requirement for missing payload keys, and the clear error when a collection doesn't exist. These are exactly the failure modes and gotchas an agent cannot see from the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with the purpose and the mode-selection rule, then organized into modes, prefetch nesting, results, tuning and examples — a sensible structure for a 21-parameter tool with deeply nested options. It is nonetheless very long and partly duplicates schema text (the MMR/candidates_limit explanation appears near-verbatim in MmrInput), which costs it the top score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool this complex, everything an agent needs to construct a valid call is present: mode exclusivity, nesting rules for prefetch/fusion, the formula grammar deliberately omitted from the recursive schema, paging limits, and seven worked examples covering plain, text, hybrid, MMR, formula and order_by. Return-shape explanation is not required since an output schema exists, and with_payload behavior is still covered.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With schema description coverage reported at 0%, the description carries the full semantic burden and does so: it explains the four accepted forms of query_vector (dense, multivector, sparse shape, point id with the source point excluded), how using/lookup_from resolve, what with_payload accepts (true/false or a key list with dotted nesting), and what each search_params knob and consistency mode means. Only with_vectors goes unmentioned in prose, a negligible gap against the rest.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a specific verb+resource ("Search a collection with Qdrant's unified Query API") and enumerates the seven query modes so the agent knows exactly what capability this covers. It never names a sibling (e.g. qdrant_points_scroll for unfiltered listing or qdrant_points_get for id lookup), so the boundary with the other read tools must be inferred from the mode list rather than stated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

"Exactly one query mode is required" plus per-mode preconditions (query_text needs the embeddings extra, bm25_query needs a text index with scoring, order_by needs a payload range index, formula requires prefetch) gives strong within-tool guidance on which mode to pick and when a mode will fail. What is missing is cross-tool routing: it never says when to prefer qdrant_points_scroll, qdrant_points_get, or qdrant_points_count instead of a query.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.