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

io.github.avaazquezz/mcp-qdrant

by avaazquezz

Delete Qdrant points

qdrant_points_delete
DestructiveIdempotent

Delete Qdrant points from a collection by ID list or payload filter, using exactly one selector; nonexistent IDs are ignored.

Instructions

Delete points by id list or by payload filter — exactly one of the two.

    Deleting an id that doesn't exist is not an error (Qdrant treats it as
    a no-op); this only fails if the collection itself is missing, or if
    you provide zero or both selectors.

    Example (by id): {"collection_name": "docs", "ids": [1, 2]}
    Example (by filter): {"collection_name": "docs", "points_filter": {
        "must": [{"key": "city", "match": {"value": "ny"}}]
    }}
    

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

Input Schema

NameRequiredDescriptionDefault
idsNo
points_filterNo
collection_nameYes

Output Schema

NameRequiredDescriptionDefault
statusYes
operation_idNoSequential number of the operation

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changedv2.12.0
    • changedInput schema / properties / points_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"
      +  }
      +]
  2. Changed2 schema fields changedv2.6.0
    • removedInput schema / $defs
      Removed value: -{
      -  "DatetimeRange": {
      -    "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"
      -  },
      -  "FieldCondition": {
      -    "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"
      -  },
      -  "Filter": {
      -    "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"
      -  },
      -  "GeoBoundingBox": {
      -    "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"
      -  },
      -  "GeoLineString": {
      -    "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"
      -  },
      -  "GeoPoint": {
      -    "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"
      -  },
      -  "GeoPolygon": {
      -    "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"
      -  },
      -  "GeoRadius": {
      -    "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"
      -  },
      -  "HasIdCondition": {
      -    "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"
      -  },
      -  "HasVectorCondition": {
      -    "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"
      -  },
      -  "IsEmptyCondition": {
      -    "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"
      -  },
      -  "IsNullCondition": {
      -    "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"
      -  },
      -  "MatchAny": {
      -    "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"
      -  },
      -  "MatchExcept": {
      -    "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"
      -  },
      -  "MatchPhrase": {
      -    "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"
      -  },
      -  "MatchPrefix": {
      -    "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"
      -  },
      -  "MatchText": {
      -    "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"
      -  },
      -  "MatchTextAny": {
      -    "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"
      -  },
      -  "MatchValue": {
      -    "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"
      -  },
      -  "MinShould": {
      -    "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"
      -  },
      -  "Nested": {
      -    "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"
      -  },
      -  "NestedCondition": {
      -    "additionalProperties": false,
      -    "properties": {
      -      "nested": {
      -        "$ref": "#/$defs/Nested",
      -        "description": ""
      -      }
      -    },
      -    "required": [
      -      "nested"
      -    ],
      -    "title": "NestedCondition",
      -    "type": "object"
      -  },
      -  "PayloadField": {
      -    "additionalProperties": false,
      -    "description": "Payload field",
      -    "properties": {
      -      "key": {
      -        "description": "Payload field name",
      -        "title": "Key",
      -        "type": "string"
      -      }
      -    },
      -    "required": [
      -      "key"
      -    ],
      -    "title": "PayloadField",
      -    "type": "object"
      -  },
      -  "Range": {
      -    "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"
      -  },
      -  "Slice": {
      -    "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"
      -  },
      -  "SliceCondition": {
      -    "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"
      -  },
      -  "ValuesCount": {
      -    "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"
      -  }
      -}
    • changedInput schema / properties / points_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"
      +  }
      +]
  3. First observedv1.1.1

TDQS

A4.1/5.0
Behavior4/5

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

Annotations already declare destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered structurally. The description still adds real value beyond that: deleting a nonexistent id is a no-op rather than an error, and failures occur only for a missing collection or an invalid selector combination — exactly the operational detail an agent needs before a destructive call.

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 core rule in the first clause, then the error semantics, then examples. Every sentence earns its place, though the two JSON examples could be trimmed to one given the nested filter description already in the schema.

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?

An output schema exists, so return values need not be described. For a destructive three-parameter tool, the definition covers selector exclusivity, failure modes, no-op semantics and format examples — nothing an agent needs in order to invoke it correctly is missing.

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

Parameters4/5

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

Top-level schema coverage is 0%, so the description must carry the load, and it does partially: it explains the mutual exclusivity of ids vs points_filter and supplies a worked example for each, including the shape of a filter condition ('key' + 'match'). It falls short on id typing — the schema permits integers or strings (UUIDs) but the example only shows integers — and leaves collection_name entirely to the schema.

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?

States a specific verb ('Delete') and resource ('points') and immediately narrows scope to the two supported selectors ('by id list or by payload filter'). An agent can distinguish it from qdrant_collection_delete and qdrant_points_get/scroll from the resource alone, though no sibling is named explicitly to reinforce the boundary.

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?

Gives an explicit selection rule — exactly one of ids or points_filter — and spells out the failure conditions (missing collection, zero or both selectors). It does not address when to reach for this versus siblings like qdrant_points_upsert or qdrant_collection_delete, so the routing guidance is constraint-based rather than comparative.

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