io.github.avaazquezz/mcp-qdrant

qdrant_query

Read-onlyIdempotent

Search Qdrant collections using vector similarity, hybrid fusion, reranking, MMR diversity, payload score 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. 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), and don't page an MMR query
      with `offset` — it is applied inside the `limit` re-ranked results
      (`offset` 1 with `limit` 2 returns one point); raise `limit` instead.
    - `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 or a `fusion` of
    its own nested `prefetch` stages, so pipelines nest: fuse dense+sparse
    in one stage, then rerank with a multivector. `using` selects a named
    vector; `lookup_from` resolves `query_vector` from a point id in
    another collection.

    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 (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}

Input Schema

Name	Required	Description	Default
`mmr`	No
`limit`	No
`using`	No
`fusion`	No
`offset`	No
`sample`	No
`formula`	No
`order_by`	No
`prefetch`	No
`consistency`	No
`lookup_from`	No
`query_filter`	No
`query_vector`	No
`with_payload`	No
`with_vectors`	No
`search_params`	No
`collection_name`	Yes
`score_threshold`	No
`timeout_seconds`	No

Output Schema

Name	Required	Description	Default
`points`	Yes

Schema Changelog

Changes observed during successful MCP inspections.

Changed56 schema fields changedv2.6.0Oct 25, 2026

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"
+}

First observedv1.1.1Sep 1, 2026

TDQS

A4.9/5.0

Behavior5/5

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

Beyond the readOnly/idempotent annotations, the description adds operational behavior the annotations cannot convey: the server-side QDRANT_MCP_MAX_LIMIT of 1000 and the paging workaround, server-side timeout and consistency semantics, Qdrant rejecting mismatched RRF weights, missing payload keys requiring `defaults`, and a clear error when the collection is absent.

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?

The structure is excellent: mode list up front, one bullet per mode, a tuning paragraph, then examples. It is long, and the exhaustive formula operator enumeration (div/left-right, decays, etc.) is heavy, but that grammar is intentionally excluded from the schema, so the length largely earns its place. A slightly tighter formula section would push this to a 5.

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?

With 19 parameters, no top-level schema descriptions, an output schema already defining return values, and annotations covering safety, the description supplies the missing semantic layer through mode rules, tuning notes, error behavior, and five concrete examples. Nothing an agent needs to construct a valid call appears to be missing.

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?

Schema coverage is reported at 0% for top-level parameters, so the description must carry the load — and it does. It clarifies the accepted types for query_vector (dense, multivector, sparse with indices/values, point id), explains prefetch nesting, spells out the full formula expression grammar, documents order_by shape and index requirement, and gives meaning to limit/offset, score_threshold, search_params knobs and consistency values.

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

Purpose5/5

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

The opening sentence names the specific tool (Qdrant's unified Query API) and enumerates all retrieval modes: vector similarity, hybrid fusion, reranking, MMR, formula scoring, ordering and sampling. An agent can tell immediately this is the retrieval tool and distinguish it from siblings like qdrant_points_scroll or qdrant_points_get.

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

Usage Guidelines5/5

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

It explicitly states that exactly one query mode is required and then describes each mode, pairing them with concrete conditions (e.g. fusion needs 2+ prefetch stages, formula requires prefetch, order_by needs a payload range index). The MMR guidance even explains a concrete misuse (offset inside re-ranked results) and the fix.

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

Deploy Server