What can you do with this server?

This MCP server lets an LLM client manage and query a Qdrant vector database end-to-end, without generating embeddings or parsing/chunking documents. * Manage collections: create, list, inspect, update, delete, and check existence. * Manage points: upsert, retrieve, delete, scroll/page, and count. * Query/search: vector similarity, hybrid fusion (RRF/DBSF), nested prefetch/reranking, MMR, score formulas, order-by, random sampling, batches, groups, recommend, discover, and distance matrices. * Edit payloads and vectors: set/overwrite/delete/clear payloads, manage payload indexes, facet counts, named-vector create/delete/update, and ordered batch operations. * Administer data: aliases, shard/optimizer status, server-side collection copy, and payload-schema inference. * Back up/restore: collection and full-storage snapshots. * Observe the server: telemetry, Prometheus metrics URL, quotas, and self-diagnosed issues. * Control exposure: enable toolsets selectively and run in read-only mode; supports local stdio and authenticated streamable-http.

How do I use io.github.avaazquezz/mcp-qdrant?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@io.github.avaazquezz/mcp-qdrant find similar documents to 'MCP server setup' in the docs collection" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

io.github.avaazquezz/mcp-qdrant

by avaazquezz

Overview Schema Source Related Servers Discussions Admin

Python

Hybrid

Qdrant MCP

PyPI version Python versions License: MIT

Qdrant MCP server

A Model Context Protocol (MCP) server that exposes the full Qdrant vector database API as tools — collection management, advanced hybrid search, payload and vector editing, snapshots, and server observability. Not just store/find.

Related MCP server: Qdrant MCP Server

Overview

Qdrant MCP is a thin MCP server that wraps the Qdrant API one-to-one: it registers a tool per Qdrant operation, validates the input with Pydantic, calls the official qdrant-client SDK, and returns the result. It never generates embeddings, never parses documents, and never decides how to chunk text — it is not a RAG system, on purpose. Whatever an LLM client wants to store or query, it brings its own vectors.

That focus is also what sets it apart from the official Qdrant MCP server, which exposes exactly two tools (store/find) and does embed documents for you. This server covers the rest of Qdrant's surface — everything under collections, points, search, payload, indexing, snapshots, and observability — so an LLM client can manage a Qdrant deployment end to end, not just push and pull memories through a narrow interface.

See ROADMAP.md for the full phase-by-phase design history, including every finding that shaped a decision (in Spanish).

Key Features

Full collection & point lifecycle — create/update/delete collections, CRUD on points, scrolling, counting.
Every Qdrant search mode — plain vector search over dense, sparse and multivectors, hybrid search (RRF — optionally weighted — and DBSF fusion), nested multi-stage prefetch (fuse dense+sparse, then rerank with a multivector), MMR diversity, custom score formulas (payload boosts, recency and geo decay), ordering by a payload field, random sampling, grouped queries, recommend, discover, and pairwise distance matrices. Search accuracy knobs (search_params, score_threshold, paging, timeouts) are accepted by every search tool.
Payload & vector editing — set/overwrite/delete/clear payload, payload indexes, facet counting, named (dense/sparse) vector management, ordered batch operations.
Snapshots — per-collection and full-storage backup/restore.
Aliases, reindexing & introspection — switch the collection a name points to without downtime, copy points between collections server-side (vectors never pass through the model), check shard layout and whether the optimizer has finished indexing, and profile the payload keys a collection actually has before writing a filter.
Observability — telemetry, Prometheus metrics endpoint, resource quotas, self-diagnosed issues.
Opt-in tool surface — tools are grouped into toolsets you enable explicitly, so a client isn't handed 60+ overlapping tools by default.
Read-only guard — one flag removes every mutating tool from the registry entirely.
Easy on the model's context — the schemas the server advertises are compact (Qdrant's verbose Filter and configuration models are summarized, validation unchanged), so the default toolset costs ~44 KB of schema instead of ~150 KB, and a per-call result cap (QDRANT_MCP_MAX_LIMIT) stops one mistaken limit from flooding the conversation.
Resilient by default — every Qdrant call goes through retry-with-backoff and returns Qdrant's own error message on failure, never a generic exception.

Requirements

Python 3.12+
Qdrant server v1.19.0 or newer. Two tools (qdrant_collection_vector_create/qdrant_collection_vector_delete) depend on an endpoint that returns 404 on older Qdrant servers (verified against v1.13.6 and v1.15.1) — everything else works on older versions, but v1.19.0+ is the only version this project tests against.

Installation

PyPI

# Run without installing (recommended for Claude Desktop/Code configs)
uvx mcp-qdrant

# Or install into your environment
pip install mcp-qdrant

Docker

docker run --rm -p 8000:8000 \
  -e QDRANT_URL=http://host.docker.internal:6333 \
  -e QDRANT_MCP_TRANSPORT=streamable-http \
  -e QDRANT_MCP_HTTP_HOST=0.0.0.0 \
  -e QDRANT_MCP_SHARED_SECRET=<a long random secret> \
  ghcr.io/avaazquezz/qdrant-mcp:latest

The image only makes sense with streamable-http — stdio needs a client to own the process's stdin/stdout directly, which a detached container can't provide. The server binds 127.0.0.1 by default, so QDRANT_MCP_HTTP_HOST=0.0.0.0 is required for the port to be reachable from outside the container. Images are published on every tagged release as {version}, {major}.{minor}, and latest.

Claude Desktop bundle (`.mcpb`)

Download mcp-qdrant.mcpb from the latest release and double-click it. Claude Desktop installs the server via uv (resolving dependencies on your machine, no Python installation required) and prompts for Qdrant URL, API key, local path, toolsets, and read-only mode through its own settings form — no JSON to edit.

Quick Start

Point the server at a local Qdrant instance over stdio and confirm it's reachable:

QDRANT_URL=http://localhost:6333 mcp-qdrant

Once connected from an MCP client, a typical first exchange looks like:

qdrant_health_check — confirms the configured Qdrant instance is reachable before doing anything else.
qdrant_collection_create — {"collection_name": "docs", "vector_size": 4, "distance": "Cosine"}.
qdrant_points_upsert — {"collection_name": "docs", "points": [{"id": 1, "vector": [0.1, 0.2, 0.3, 0.4], "payload": {"title": "hello"}}]}.
qdrant_query — {"collection_name": "docs", "query_vector": [0.1, 0.2, 0.3, 0.4], "limit": 5}.

The full parameter shape of every tool is described in its own MCP schema — an LLM client reads those directly via tools/list; the table in Available Tools below is a human-readable summary of the same data.

Connecting to Claude

Claude Desktop / Claude Code (local, `stdio`)

claude_desktop_config.json (Claude Desktop) or .mcp.json (Claude Code):

{
  "mcpServers": {
    "qdrant": {
      "command": "uvx",
      "args": ["mcp-qdrant"],
      "env": {
        "QDRANT_URL": "http://localhost:6333",
        "QDRANT_MCP_TOOLSETS": "core,search"
      }
    }
  }
}

Or use the .mcpb bundle described in Installation — same result, no JSON to edit.

Remote (`streamable-http`)

For a server reachable over the network (e.g. added as a custom connector in Claude.ai) with a single, fixed backing Qdrant. QDRANT_MCP_SHARED_SECRET is required in this mode — the server refuses to start as streamable-http without one, to avoid serving an unauthenticated endpoint over the network (verified hands-on: an open streamable-http server is trivially usable by anyone with the URL).

QDRANT_URL=http://localhost:6333 \
QDRANT_MCP_TRANSPORT=streamable-http \
QDRANT_MCP_HTTP_HOST=0.0.0.0 \
QDRANT_MCP_SHARED_SECRET=<a long random secret> \
mcp-qdrant

In Claude.ai (Customize → Connectors → Add custom connector, verified hands-on against a real account): enter the server's HTTPS URL, then on the detected authentication screen choose "None" and add a Request header — Authorization → Bearer <the same secret>. (Authorization is used here because it's one of the two header names Claude.ai's custom-connector UI accepts without requiring Anthropic's manual approval of a custom name.)

Configuration Reference

All configuration is via environment variables, read once at startup — a misconfiguration fails immediately instead of surfacing later as a confusing tool error.

Variable	Default	Required	Purpose
`QDRANT_URL`	—	No¹	URL of your Qdrant instance, e.g. `http://localhost:6333` or a Qdrant Cloud URL.
`QDRANT_API_KEY`	—	No	API key for `QDRANT_URL`, if your instance requires one.
`QDRANT_LOCAL_PATH`	—	No¹	Path to an embedded/on-disk Qdrant instance, instead of a URL.
`QDRANT_MCP_READ_ONLY`	`false`	No	Removes every tool not marked read-only from the registry. See Read-Only Mode.
`QDRANT_MCP_TRANSPORT`	`stdio`	No	`stdio` (local, for Claude Desktop/Code) or `streamable-http` (network).
`QDRANT_MCP_TOOLSETS`	`core`	No	Comma-separated list of toolsets to register. See Available Tools.
`QDRANT_MCP_SHARED_SECRET`	—	Yes, for `streamable-http`	Bearer token clients must send in the `Authorization` header.
`QDRANT_MCP_HTTP_HOST`	`127.0.0.1`	No	Bind host for `streamable-http`. Use `0.0.0.0` in a container.
`QDRANT_MCP_HTTP_PORT`	`8000`	No	Bind port for `streamable-http`.
`QDRANT_MCP_MAX_LIMIT`	`1000`	No	Largest number of points one tool call may ask for (minimum 30, so every tool's default request fits) (`limit`, groups' `limit × group_size`, a batch's total, the number of ids, ...). A bigger request is refused with a message saying to page, not silently cut.

¹ QDRANT_URL and QDRANT_LOCAL_PATH are mutually exclusive; if neither is set, the client falls back to the qdrant-client SDK's own default of localhost:6333.

Available Tools

Tools are grouped into toolsets, enabled via QDRANT_MCP_TOOLSETS (comma-separated). Only core is enabled by default — the rest are explicit opt-ins, so a client isn't handed every tool at once:

core — collection and point CRUD, plus qdrant_query and the qdrant_health_check smoke test. Enough for a fully working MCP on its own.
search — everything beyond plain vector search: batched/grouped queries, recommend, discover, and pairwise distance matrices.
payload — payload editing and indexing, named-vector management, ordered batch point operations.
snapshots — collection and full-storage backup/restore.
observability — telemetry, metrics, quotas, and self-diagnosed issues.
admin — collection aliases, per-collection shard layout and optimizer progress, and two composite operations that keep the data on the server: copying points between collections (the missing half of a zero-downtime reindex) and profiling the payload keys a collection really has. Everything here works on a single node; distributed-cluster administration (shard keys, resharding) is out of scope — see ROADMAP.md, Fase 5 and Fase 12.

The table below is generated directly from the live tool registry — run uv run python scripts/gen_tools_doc.py after adding or changing a tool to keep it in sync (CI fails the build if it drifts).

Tool	Toolset	Read-only	Destructive	Idempotent	Description
`qdrant_health_check`	`core`	✅	❌	✅	Confirm the configured Qdrant instance is reachable and responding.
`qdrant_collection_create`	`core`	❌	❌	❌	Create a collection: either a single unnamed vector (`vector_size` + `distance`), or one or more named vectors (`vectors`, each a full `VectorParams` — size, distance, and optionally its own `multivector_config` for ColBERT-style multi-vectors or `quantization_config`) — exactly one of the two.
`qdrant_collection_list`	`core`	✅	❌	✅	List every collection name in the configured Qdrant instance.
`qdrant_collection_info`	`core`	✅	❌	✅	Return full config and status of one collection.
`qdrant_collection_update`	`core`	❌	❌	✅	Update optimizer/HNSW/collection/vector params on an existing collection.
`qdrant_collection_delete`	`core`	❌	✅	✅	Delete a collection and all its points; a no-op if it doesn't exist.
`qdrant_collection_exists`	`core`	✅	❌	✅	Check whether a collection exists, without raising if it doesn't.
`qdrant_points_upsert`	`core`	❌	✅	✅	Insert or replace points (id + vector + payload) in a collection.
`qdrant_points_get`	`core`	✅	❌	✅	Retrieve points by id; unknown ids are simply omitted, not an error.
`qdrant_points_delete`	`core`	❌	✅	✅	Delete points by id list or by payload filter — exactly one of the two.
`qdrant_points_scroll`	`core`	✅	❌	✅	Page through all points in a collection, optionally filtered.
`qdrant_points_count`	`core`	✅	❌	✅	Count points in a collection, optionally matching a filter.
`qdrant_query`	`core`	✅	❌	✅	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.
`qdrant_query_batch`	`search`	✅	❌	✅	Run multiple independent queries against one collection in a single round trip — each item takes every query mode and tuning parameter of `qdrant_query` (plain vector, fusion over prefetch, MMR, formula, order_by, sample, search_params, score_threshold, offset); `timeout_seconds` and `consistency` apply to the whole batch.
`qdrant_query_groups`	`search`	✅	❌	✅	Vector query grouped by a payload field, up to `group_size` hits per group — e.g. the best-matching chunks per source document.
`qdrant_recommend`	`search`	✅	❌	✅	Find points similar to a set of positive examples and dissimilar to a set of negative ones (vectors or point ids) — Qdrant's recommendation API.
`qdrant_recommend_batch`	`search`	✅	❌	✅	Run multiple independent recommend queries against one collection in a single round trip.
`qdrant_recommend_groups`	`search`	✅	❌	✅	Recommend query grouped by a payload field, up to `group_size` hits per group.
`qdrant_discover`	`search`	✅	❌	✅	Rank points by how well they fit a target within positive/negative context pairs (vectors or point ids) — Qdrant's discovery search, a finer-grained alternative to recommend.
`qdrant_discover_batch`	`search`	✅	❌	✅	Run multiple independent discover queries against one collection in a single round trip.
`qdrant_distance_matrix_pairs`	`search`	✅	❌	✅	Pairwise distance matrix between a random sample of points: for each of `sample` points, its `limit` closest neighbors among that same sample — returned as a flat list of (a, b, score) pairs.
`qdrant_distance_matrix_offsets`	`search`	✅	❌	✅	Same distance matrix as `qdrant_distance_matrix_pairs`, in a column-oriented shape (offsets into a shared id list + a parallel score array) — more compact for large samples.
`qdrant_payload_set`	`payload`	❌	❌	✅	Merge fields into the payload of selected points — exactly one of `ids`/`points_filter`.
`qdrant_payload_overwrite`	`payload`	❌	✅	✅	Replace the entire payload of selected points with `payload` — exactly one of `ids`/`points_filter`.
`qdrant_payload_delete`	`payload`	❌	✅	✅	Delete specific payload keys from selected points — exactly one of `ids`/`points_filter`.
`qdrant_payload_clear`	`payload`	❌	✅	✅	Wipe the entire payload of selected points, keeping their vectors — exactly one of `ids`/`points_filter`.
`qdrant_payload_facet`	`payload`	✅	❌	✅	Count distinct values of a payload field across the collection (or a filtered subset) — e.g. how many points per `city`.
`qdrant_payload_index_create`	`payload`	❌	❌	✅	Create a payload index on `field_name`, speeding up filters that use it.
`qdrant_payload_index_delete`	`payload`	❌	✅	✅	Delete the payload index on `field_name`.
`qdrant_collection_vector_create`	`payload`	❌	❌	✅	Add a new named vector (dense or sparse) to a collection that already has points, without touching them.
`qdrant_collection_vector_delete`	`payload`	❌	✅	✅	Remove a named vector (dense or sparse) from a collection — points keep their other vectors and payload.
`qdrant_points_batch_update`	`payload`	❌	✅	❌	Run multiple point operations (upsert, delete, set/overwrite/delete/clear payload, update/delete vectors) against one collection, in the order given, in a single request.
`qdrant_vectors_update`	`payload`	❌	✅	✅	Replace the vector(s) of existing points by id — leaves their payload untouched.
`qdrant_vectors_delete`	`payload`	❌	✅	✅	Remove specific named vectors from selected points, keeping their payload and other vectors — exactly one of `ids`/`points_filter`.
`qdrant_alias_list`	`admin`	✅	❌	✅	List every alias on the server with the collection it points to.
`qdrant_collection_aliases`	`admin`	✅	❌	✅	List the aliases that point to one collection (an empty list if it has none).
`qdrant_alias_update`	`admin`	❌	✅	❌	Create, rename, re-point or delete aliases — the basis of a zero-downtime reindex: build the new collection, then switch the alias that clients use.
`qdrant_collection_cluster_info`	`admin`	✅	❌	✅	Shard layout of a collection: how many shards it has and, for each local shard, its point count and replica state.
`qdrant_collection_optimizations`	`admin`	✅	❌	✅	Progress of the background optimizer for a collection — answers "has it finished indexing?" and "why isn't the collection green?".
`qdrant_collection_copy`	`admin`	❌	✅	✅	Copy points (all vectors — dense, sparse and multivector — and payload) from one collection to another of the same Qdrant instance, entirely server-side: the vectors never pass through the model.
`qdrant_payload_schema_infer`	`admin`	✅	❌	✅	Profile the payload keys that actually occur in a collection, so filters can be written against real keys instead of guessed ones.
`qdrant_snapshot_create`	`snapshots`	❌	❌	❌	Create a snapshot of one collection's current state.
`qdrant_snapshot_list`	`snapshots`	✅	❌	✅	List the snapshots stored for one collection.
`qdrant_snapshot_delete`	`snapshots`	❌	✅	✅	Delete a collection snapshot, freeing its disk space on the server — does not touch the live collection.
`qdrant_snapshot_recover`	`snapshots`	❌	✅	✅	Overwrite `collection_name` with the state captured in a snapshot — everything written since that snapshot is lost.
`qdrant_snapshot_download`	`snapshots`	✅	❌	✅	Confirm a collection snapshot exists and return where to fetch it from — this tool does not transfer the (potentially huge) snapshot file itself; download it yourself (e.g. `curl`) from the returned `url`.
`qdrant_storage_snapshot_create`	`snapshots`	❌	❌	❌	Create a snapshot of the whole storage (every collection and server config), not just one collection.
`qdrant_storage_snapshot_list`	`snapshots`	✅	❌	✅	List the full-storage snapshots stored on the server.
`qdrant_storage_snapshot_delete`	`snapshots`	❌	✅	✅	Delete a full-storage snapshot, freeing its disk space.
`qdrant_storage_snapshot_download`	`snapshots`	✅	❌	✅	Confirm a full-storage snapshot exists and return where to fetch it from — same caveat as `qdrant_snapshot_download`: this tool does not transfer the file itself.
`qdrant_telemetry`	`observability`	✅	❌	✅	Server-wide telemetry: build info, per-collection stats, request counters, memory and hardware usage.
`qdrant_metrics_prometheus`	`observability`	✅	❌	✅	Return the URL where Qdrant serves Prometheus-format metrics — this tool does not fetch the metrics themselves (they're plain text, not JSON); point your Prometheus scraper at the returned `url` instead.
`qdrant_quotas_get`	`observability`	✅	❌	✅	Current server-wide resource quotas (memory/disk limits) and actual usage.
`qdrant_quotas_set`	`observability`	❌	❌	✅	Update server-wide resource quotas.
`qdrant_issues_list`	`observability`	✅	❌	✅	List the issues Qdrant has detected about its own configuration (e.g. a heavily-filtered field with no payload index).
`qdrant_issues_clear`	`observability`	❌	✅	✅	Clear all accumulated issues.

Read-Only Mode

Setting QDRANT_MCP_READ_ONLY=1 removes every tool whose destructiveHint isn't explicitly false (i.e. anything that isn't readOnlyHint=true) from the registry itself — a client calling tools/list never sees them, rather than seeing them and having calls rejected. This is the mechanism to hand an LLM client safe, read-only access to a Qdrant deployment: point it at your database, set the flag, and there is no code path left for it to write anything.

Architecture

Single shared client. One AsyncQdrantClient is built once at startup and closed over by every tool.
One registration choke point. Every tool module calls into a single ToolRegistry, which is where the toolset filter and the read-only guard are both enforced — a tool can't bypass either by registering itself differently.
Resilience. Every Qdrant call is wrapped with tenacity-based retry and backoff (the qdrant-client SDK itself only exposes a timeout, not retries), and translated into an MCP ToolError carrying Qdrant's own error message instead of a generic failure — so "collection not found" reads as exactly that.
stdio-safe logging. All logging goes to stderr, configured before the MCP server object is even constructed — writing to stdout under the stdio transport would corrupt the JSON-RPC message framing.

Security

Mandatory authentication for streamable-http. The server refuses to start without QDRANT_MCP_SHARED_SECRET — verified hands-on that an unauthenticated instance is trivially usable by anyone with the URL.
Input validation everywhere. Every tool's input is a Pydantic model — malformed input is rejected with a structured error before it reaches the Qdrant SDK.
Read-only guard. QDRANT_MCP_READ_ONLY removes every mutating tool from the registry — see Read-Only Mode.

Development

git clone https://github.com/avaazquezz/Qdrant-MCP.git
cd Qdrant-MCP
uv sync --dev
uv run pre-commit install

uv run ruff check .            # lint
uv run ruff format --check .   # formatting
uv run mypy .                  # type checking (strict)
uv run pytest                  # unit tests
uv run pytest -m integration   # integration tests — needs a running Qdrant (CI runs one as a Docker service)

If you add or change a tool, regenerate the table in Available Tools rather than hand-editing it:

uv run python scripts/gen_tools_doc.py          # regenerate
uv run python scripts/gen_tools_doc.py --check  # verify, no changes (what CI runs)

Versioning & Changelog

This project follows Semantic Versioning. See CHANGELOG.md for release notes and ROADMAP.md for the phased design history behind each version.

License

MIT

Available Tools

13 tools

qdrant_collection_createA

Create a collection: either a single unnamed vector (vector_size + distance), or one or more named vectors (vectors, each a full VectorParams — size, distance, and optionally its own multivector_config for ColBERT-style multi-vectors or quantization_config) — exactly one of the two. sparse_vectors defines sparse (keyword-style) vectors at creation time. quantization_config (scalar/product/binary) and strict_mode_config apply to the whole collection.

    `hnsw_config` and `optimizers_config` set the index and optimizer
    parameters from the start (they can also be changed later with
    `qdrant_collection_update`); `on_disk_payload=true` keeps payloads
    on disk instead of in RAM, which can only be chosen here.

    Fails with a clear error if a collection with this name already exists.

    Example (simple): {"collection_name": "docs", "vector_size": 4, "distance": "Cosine"}
    Example (hybrid): {"collection_name": "docs", "vectors": {
        "dense": {"size": 4, "distance": "Cosine"}
    }, "sparse_vectors": {"sparse": {}}}
    Example (multitenant index, payload on disk): {"collection_name": "docs",
        "vector_size": 4, "hnsw_config": {"m": 0, "payload_m": 16},
        "on_disk_payload": true}

Name	Required	Default
`vectors`	No
`distance`	No	Cosine
`metadata`	No
`hnsw_config`	No
`vector_size`	No
`sparse_vectors`	No
`collection_name`	Yes
`on_disk_payload`	No
`optimizers_config`	No
`strict_mode_config`	No
`quantization_config`	No

Output Schema

Name	Required	Description
`config`	Yes	Current statistics and configuration of the collection
`status`	Yes	Current statistics and configuration of the collection
`warnings`	No	Warnings related to the collection
`points_count`	No	Approximate number of points (vectors + payloads) in collection. Each point could be accessed by unique id.
`update_queue`	No	Update queue info
`payload_schema`	Yes	Types of stored payload
`segments_count`	Yes	Number of segments in collection. Each segment has independent vector as payload indexes
`optimizer_status`	Yes	Current statistics and configuration of the collection
`indexed_vectors_count`	No	Approximate number of indexed vectors in the collection. Indexed vectors in large segments are faster to query, as it is stored in a specialized vector index.

TDQS

A4.4/5.0

Behavior4/5

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

Annotations already declare this is a non-read-only, non-idempotent, non-destructive write. The description goes beyond them with genuinely useful facts: the name-collision failure mode, and the key immutability constraint that `on_disk_payload` can only be chosen at creation while `hnsw_config`/`optimizers_config` are mutable later. It stops short of stating permissions/auth needs or what a successful response contains.

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-loads the core decision before the optional configuration detail, and every paragraph addresses a distinct concern. The three worked examples earn their space by disambiguating the alternatives concretely, though the description is on the long side for a create call.

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 no prose. For a high-parameter create tool the description covers the shape selection, immutability boundaries, mutability of other configs, error behavior, and worked examples. The only residual gap is the undocumented `metadata` parameter, which is minor against the whole.

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?

With 0% schema description coverage across 11 parameters, the description carries the full burden and largely meets it: it explains the roles of `vector_size`, `distance`, `vectors`, `sparse_vectors`, `quantization_config`, `strict_mode_config`, `hnsw_config`, `optimizers_config`, and `on_disk_payload`, including the ColBERT-style multivector case. However, `metadata` is never mentioned and the fields inside `optimizers_config`/`strict_mode_config` get no semantic explanation beyond their group names.

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?

States a specific verb and resource ('Create a collection') and immediately enumerates the two mutually exclusive configuration shapes (single unnamed vector vs. named `vectors`). This clearly separates it from `qdrant_collection_update`, `qdrant_collection_delete`, and `qdrant_collection_list`, which are named outright.

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?

Explicitly states the 'exactly one of the two' constraint for `vector_size`+`distance` vs `vectors`, which is the main branching decision an agent faces. It also routes future changes to `qdrant_collection_update` and warns that creation fails if the name already exists. It does not point to the `qdrant_collection_exists` sibling as a pre-check, leaving that inference to the agent.

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

qdrant_collection_deleteA

DestructiveIdempotent

Delete a collection and all its points; a no-op if it doesn't exist.

    Example: {"collection_name": "docs"}

Name	Required	Description	Default
`collection_name`	Yes

Output Schema

Name	Required	Description
`deleted`	Yes

TDQS

A4.5/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 readOnlyHint=false. The description adds value by specifying that it deletes not only the collection but also all its points, and that it is a no-op if the collection does not exist. This goes beyond the annotation flags by detailing the scope and idempotent outcome, which helps the agent predict the effect. No contradiction is present.

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

Conciseness5/5

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

The description is two sentences plus a code example, with zero fluff. It front-loads the core behavior (delete and scope), states idempotency, and gives a concrete example. Every word earns its place.

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

Completeness5/5

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

For a simple one-parameter destructive tool, this description is complete. It covers the action, scope, idempotency, and an example. Given that an output schema exists, the return format does not need to be explained in the description. The annotations cover safety, and the tool's purpose is unmistakable.

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?

With schema description coverage at 0%, the description must compensate, and it does so with a clear example: {'collection_name': 'docs'}. The parameter name itself (collection_name) and its title (Collection Name) are already self-explanatory, and the example demonstrates the expected string format. This adds meaning beyond the schema's basic type and title.

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 description clearly states the verb 'Delete' and the resource 'a collection and all its points', which is specific and unambiguous. It also distinguishes itself from sibling tools like qdrant_collection_create or qdrant_collection_update by its destructive nature. The idempotency note ('no-op if it doesn't exist') further clarifies the exact behavior.

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?

The description does not explicitly mention alternatives or when-not-to-use, but it conveys that the operation is safe to call regardless of existence (no-op if absent). This provides enough context to decide when to invoke it, and the clear verb 'delete' leaves little ambiguity about its purpose. However, it could explicitly state that this is the tool to permanently remove collections, versus other tools like update or list.

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

qdrant_collection_existsA

Read-onlyIdempotent

Check whether a collection exists, without raising if it doesn't.

    Example: {"collection_name": "docs"}

Name	Required	Description	Default
`collection_name`	Yes

Output Schema

Name	Required	Description
`exists`	Yes

TDQS

A4.5/5.0

Behavior4/5

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds a meaningful behavioral guarantee beyond annotations: it will not raise when the collection is absent. This is useful for an agent deciding how to handle negative results.

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

Conciseness5/5

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

Two short sentences with an embedded example; every line earns its place. The core behavior is front-loaded and no filler is present.

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

Completeness5/5

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

For a one-parameter, read-only existence check, the combination of annotations, output schema, and description fully covers what an agent needs to call it correctly. The non-raising behavior and example fill the important gaps.

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?

With 0% schema description coverage, the description's example {'collection_name': 'docs'} compensates by demonstrating the expected parameter format. The single parameter is self-explanatory from its name, and the example confirms usage.

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?

States a specific verb and resource ('Check whether a collection exists') and adds a distinctive behavioral detail ('without raising if it doesn't'). This makes it clearly distinguishable from siblings like qdrant_collection_info and qdrant_collection_list.

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?

The description clearly scopes use to existence checks, and the non-raising behavior clarifies the typical use case. It does not explicitly name alternatives or exclusion criteria, but the context is unambiguous for a simple boolean existence check.

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

qdrant_collection_infoA

Read-onlyIdempotent

Return full config and status of one collection.

    Fails with a clear error if the collection doesn't exist.

    Example: {"collection_name": "docs"}

Name	Required	Description	Default
`collection_name`	Yes

Output Schema

Name	Required	Description
`config`	Yes	Current statistics and configuration of the collection
`status`	Yes	Current statistics and configuration of the collection
`warnings`	No	Warnings related to the collection
`points_count`	No	Approximate number of points (vectors + payloads) in collection. Each point could be accessed by unique id.
`update_queue`	No	Update queue info
`payload_schema`	Yes	Types of stored payload
`segments_count`	Yes	Number of segments in collection. Each segment has independent vector as payload indexes
`optimizer_status`	Yes	Current statistics and configuration of the collection
`indexed_vectors_count`	No	Approximate number of indexed vectors in the collection. Indexed vectors in large segments are faster to query, as it is stored in a specialized vector index.

TDQS

A4.1/5.0

Behavior4/5

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive behavior. The description adds value beyond those by stating that the tool fails with a clear error when the collection does not exist, which is useful behavioral context an agent cannot infer from annotations alone.

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

Conciseness5/5

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

The description is short and well-structured: main purpose first, then failure behavior, then a concrete example. Every sentence contributes useful information with no filler.

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

Completeness5/5

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

For a single-parameter, read-only info tool with an output schema and comprehensive annotations, the description covers the necessary invocation details. The failure case is explicitly disclosed, and the example makes the parameter usage clear.

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

Parameters3/5

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

Schema description coverage is 0%, but there is only one parameter and the example {'collection_name': 'docs'} demonstrates its shape. The description partially compensates for the missing schema documentation, though it does not explain allowed values, naming constraints, or format expectations beyond the parameter title.

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 description uses a specific verb ('Return') and a specific resource ('full config and status of one collection'), clearly distinguishing it from siblings like qdrant_collection_exists and qdrant_collection_list. The singular 'one collection' removes ambiguity.

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

Usage Guidelines3/5

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

The description implies the tool is for retrieving details about a single existing collection, but it does not explicitly state when to prefer it over qdrant_collection_exists, qdrant_collection_list, or qdrant_health_check. The failure case is mentioned, which helps set expectations, but no alternatives or exclusion conditions are given.

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

qdrant_collection_listA

Read-onlyIdempotent

List every collection name in the configured Qdrant instance.

    Example: {}

Name	Required	Description	Default
No parameters

Output Schema

Name	Required	Description
`collections`	Yes

TDQS

A3.8/5.0

Behavior3/5

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds only a minor detail—that it lists names specifically—which is slightly beyond the annotation title 'List Qdrant collections' but does not disclose anything about return format, pagination, or error behavior.

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

Conciseness5/5

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

The description is a single sentence that states the action and scope without any wasted words. It is appropriately sized for a simple listing operation, and the core action is front-loaded.

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

Completeness4/5

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

For a zero-parameter listing tool with an existing output schema (which presumably describes the returned list of names), the description is complete enough. It clearly states what is returned (collection names) and the context (configured instance). No additional caveats are necessary.

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?

The tool has zero parameters, so the description does not need to explain any parameter semantics. According to the calibration, a baseline of 4 is appropriate for 0-parameter tools; the description adds no negative value here.

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 description clearly states the action (List) and the resource (collection names) in the configured Qdrant instance. It distinguishes itself from siblings like qdrant_collection_info (which likely provides details) and qdrant_collection_exists (which checks existence) by focusing on listing names only.

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

Usage Guidelines2/5

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this tool is appropriate for getting an overview of collections by name, nor does it indicate that qdrant_collection_info or qdrant_collection_exists should be used for more specific needs.

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

qdrant_collection_updateA

Idempotent

Update optimizer/HNSW/collection/vector params on an existing collection.

    Only the fields you pass are changed; omitted ones keep their current
    value. `quantization_config="disabled"` turns quantization off.
    `vectors_config`/`sparse_vectors_config` only **adjust** named
    vectors that already exist (HNSW/quantization/index tuning) — they
    cannot add a new one; use `qdrant_collection_vector_create` for
    that, or this fails with Qdrant's own "Not existing vector name"
    error. Fails with a clear error if the collection doesn't exist.

    Example: {"collection_name": "docs", "optimizers_config": {"indexing_threshold": 10000}}

Name	Required	Description	Default
`hnsw_config`	No
`vectors_config`	No
`collection_name`	Yes
`collection_params`	No
`optimizers_config`	No
`strict_mode_config`	No
`quantization_config`	No
`sparse_vectors_config`	No

Output Schema

Name	Required	Description
`config`	Yes	Current statistics and configuration of the collection
`status`	Yes	Current statistics and configuration of the collection
`warnings`	No	Warnings related to the collection
`points_count`	No	Approximate number of points (vectors + payloads) in collection. Each point could be accessed by unique id.
`update_queue`	No	Update queue info
`payload_schema`	Yes	Types of stored payload
`segments_count`	Yes	Number of segments in collection. Each segment has independent vector as payload indexes
`optimizer_status`	Yes	Current statistics and configuration of the collection
`indexed_vectors_count`	No	Approximate number of indexed vectors in the collection. Indexed vectors in large segments are faster to query, as it is stored in a specialized vector index.

TDQS

A4.4/5.0

Behavior4/5

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

The annotations already establish non-read-only, idempotent, non-destructive behavior, and the description adds meaningful context: partial update semantics, the special quantization disable value, and failure modes for missing collections or unknown vector names. It does not discuss return values, but an output schema exists.

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

Conciseness5/5

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

The description is front-loaded with the core operation, then gives the partial-update rule, vector constraint, failure behavior, and a practical example. The sentences are dense and useful, with no apparent filler.

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

Completeness4/5

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

For a complex collection-update tool with an output schema and annotations, the description covers the essential invocation context: existing collection requirement, partial updates, vector-name limitation, quantization disabling, and failure behavior. Remaining gaps are mostly detailed nested parameter semantics that the schema itself does not explain.

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

Parameters3/5

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

Schema description coverage is 0% across 8 complex top-level parameters, so the description must carry parameter meaning. It identifies the parameter categories and adds important constraints for vectors_config/sparse_vectors_config and quantization_config, plus one optimizers_config example, but it does not explain most nested fields.

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 description uses a specific verb and resource: update optimizer/HNSW/collection/vector params on an existing collection. It distinguishes the tool from vector creation by explicitly naming qdrant_collection_vector_create for adding vectors.

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 states that only passed fields are changed and omitted fields keep current values, which is the key partial-update behavior. It also gives explicit when-not guidance by naming the sibling to use for adding vectors and warning that this tool fails in that case.

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

qdrant_health_checkA

Read-onlyIdempotent

Confirm the configured Qdrant instance is reachable and responding.

    Never raises to the caller: a health check that raises on the exact
    condition it exists to detect defeats its own purpose. Connection
    failures are logged and reported in the result's ok/error fields
    instead, so a client renders them without a tool-call error round-trip.

Name	Required	Description	Default
No parameters

Output Schema

Name	Required	Description
`ok`	Yes
`error`	No
`collection_count`	No

TDQS

A4.7/5.0

Behavior5/5

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

Beyond the readOnly/ idempotent annotations, the description explicitly discloses a key behavioral trait: it never raises to the caller and instead reports connection failures in ok/error fields. This is valuable, non-obvious information that materially affects how an agent interprets results.

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

Conciseness5/5

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

The description is compact and front-loaded: the first sentence states the core purpose, and the second explains the crucial error-handling behavior. Every sentence earns its place without redundancy.

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

Completeness5/5

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

For a zero-parameter, read-only health check with an output schema, the description fully covers what an agent needs: purpose, safety profile via annotations, and the non-raising error behavior. Nothing important 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?

The tool has zero parameters, so the schema fully covers parameter semantics. The baseline of 4 applies; no parameter documentation is needed, and the description instead focuses on behavior, which is appropriate.

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 description states a specific verb and resource: 'Confirm the configured Qdrant instance is reachable and responding.' It clearly distinguishes this tool from the collection and point operation siblings, which address different concerns.

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?

The description makes clear that the tool is for confirming connectivity and responsiveness of the Qdrant instance, which provides strong usage context. It does not explicitly discuss when to avoid it or name alternatives, but none of the sibling tools serve this health-check role.

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

qdrant_points_countC

Read-onlyIdempotent

Count points in a collection, optionally matching a filter.

    Example: {"collection_name": "docs"}

Name	Required	Description	Default
`exact`	No
`count_filter`	No
`collection_name`	Yes

Output Schema

Name	Required	Description
`count`	Yes	Number of points which satisfy the conditions

TDQS

C2.7/5.0

Behavior2/5

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, so the safety profile is fully covered elsewhere. The description adds nothing beyond that: it never explains that counts may be approximate unless `exact` is set, nor mentions cost/latency on large collections. The 'exact' flag is the key behavioral lever of this tool and it goes unmentioned.

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?

Two short sentences with the core action front-loaded and no wasted prose. The example adds little, since it only repeats the one required parameter and ignores the filter and exact options.

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

Completeness2/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 no explanation, but for a 3-parameter tool the description omits two of them and gives no behavioral context. It is closer to a restated name than a usable spec for anything but the simplest unfiltered count.

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

Parameters2/5

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

Top-level schema coverage is 0%; the description only alludes to a filter without naming the `count_filter` parameter. The `exact` parameter (default true, controlling approximate vs exact counting) is completely undocumented in both the description and the schema, leaving an agent to guess its meaning.

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?

The description states a specific verb and resource ('Count points in a collection') with a scope qualifier ('optionally matching a filter'). This is enough to separate it from qdrant_points_scroll or qdrant_query, though no sibling is named explicitly.

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

Usage Guidelines2/5

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

There is no guidance on when to prefer count over qdrant_points_scroll, qdrant_query, or qdrant_collection_info, which all touch overlapping data. The only usage hint is 'optionally matching a filter', which is implied rather than explained.

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

qdrant_points_deleteA

DestructiveIdempotent

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

Name	Required	Description	Default
`ids`	No
`points_filter`	No
`collection_name`	Yes

Output Schema

Name	Required	Description
`status`	Yes
`operation_id`	No	Sequential number of the operation

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, yet the description still adds real behavioral value: deleting a nonexistent id is a no-op rather than an error, and failure is limited to missing collection or invalid selector combination. It stops short of saying whether the deletion is permanent/unrecoverable or whether a filter match can wipe an arbitrarily large set of points.

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 rule and the failure modes are front-loaded in the first two sentences, with examples trailing. The two example JSON blocks are somewhat redundant with the schema but do disambiguate the selector shape, so they mostly earn their space.

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

Completeness4/5

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

For a destructive, three-parameter mutation tool with an output schema, the description covers selection semantics, exclusivity and error behavior adequately. The remaining gap is irreversibility/blast-radius, which matters for a destructiveHint=true operation.

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

Parameters3/5

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

Schema coverage is reported as 0%, so the description carries extra weight; it compensates partly by giving a concrete example payload for each selector. However it never explains that `ids` accepts both integers and strings (point IDs vs UUIDs), and it defers entirely to the schema for the filter grammar. Baseline-plus rather than strong.

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?

States a specific verb (Delete) and resource (points) plus the two exact selection modes (id list or payload filter). This is immediately distinguishable from siblings like qdrant_points_get, qdrant_points_upsert and qdrant_points_scroll without opening any schema.

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?

Explicitly states the exclusivity rule ("exactly one of the two") and enumerates the failure conditions: missing collection, zero selectors, or both selectors. It does not name a sibling tool as the alternative for partial/soft deletion scenarios, which keeps it just short of a 5.

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

qdrant_points_getB

Read-onlyIdempotent

Retrieve points by id; unknown ids are simply omitted, not an error.

    Fails only if the collection itself doesn't exist.

    Example: {"collection_name": "docs", "ids": [1, 2]}

Name	Required	Description	Default
`ids`	Yes
`with_payload`	No
`with_vectors`	No
`collection_name`	Yes

Output Schema

Name	Required	Description
`points`	Yes

TDQS

B3.4/5.0

Behavior4/5

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral context beyond annotations: unknown IDs are silently omitted rather than raising errors, and the only failure mode is a missing collection. This is useful for an agent predicting edge-case outcomes.

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

Conciseness5/5

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

The description is compact and front-loaded: the main action and key behavioral caveat appear in the first line, followed by a failure condition and a concrete example. Every sentence adds information without filler.

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

Completeness4/5

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

Given the rich annotations and existing output schema, the description covers the key behaviors an agent needs: retrieval semantics, missing-ID handling, and failure mode. The only gap is the under-documented optional parameters, but those are simple booleans with clear names and defaults, so the overall picture is reasonably complete.

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

Parameters2/5

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

Schema description coverage is 0%, so the description must compensate. The example documents collection_name and ids, but with_payload and with_vectors are never mentioned, leaving their semantics entirely to their titles and defaults. The required parameters are illustrated, but optional parameters are neglected.

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?

The description clearly states the tool retrieves points by ID, which distinguishes it from query/scroll/list siblings. The behavior note ('unknown ids are simply omitted') further clarifies the operation's scope. It does not explicitly name sibling alternatives, so it falls just short of a 5.

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

Usage Guidelines2/5

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

The description implies the tool is for fetching specific points by ID but provides no guidance on when to choose this over qdrant_query, qdrant_points_scroll, or other siblings. There is no comparison, exclusion, or alternative mention.

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

qdrant_points_scrollA

Read-onlyIdempotent

Page through all points in a collection, optionally filtered.

    Pass the returned `next_page_offset` as `offset` to fetch the next
    page; `null` means there are no more pages. `limit` is capped per call
    by the server's QDRANT_MCP_MAX_LIMIT (1000 by default).

    `order_by` sorts by a payload field instead of by id: a key, or
    `{"key": ..., "direction": "asc"|"desc", "start_from": value}`; the key
    needs a payload range index (integer, float or datetime). Paging works
    differently then: `offset` is rejected, and `next_page_offset` is always
    `null` even when more points remain — to continue, repeat the call with
    `start_from` set to the last value you received (points tied on that
    value are returned again, so de-duplicate by id).

    Example: {"collection_name": "docs", "limit": 50}
    Example (newest first): {"collection_name": "docs", "limit": 20,
        "order_by": {"key": "created_at", "direction": "desc"}}

Name	Required	Description	Default
`limit`	No
`offset`	No
`order_by`	No
`with_payload`	No
`with_vectors`	No
`scroll_filter`	No
`collection_name`	Yes

Output Schema

Name	Required	Description
`points`	Yes
`next_page_offset`	Yes

TDQS

A4.1/5.0

Behavior5/5

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

Goes well beyond the annotations by disclosing server-side limit caps, how next_page_offset works, the null termination condition, and the non-obvious order_by paging behavior where offset is rejected and next_page_offset is always null. It also warns about duplicates when using start_from.

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

Conciseness5/5

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

Front-loaded with the core operation, then organized into pagination behavior, order_by special cases, and concrete examples. Every paragraph serves a distinct purpose and there is no filler.

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

Completeness4/5

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

Given the output schema and annotations, the description covers the most important non-obvious behaviors for correct invocation. It leaves minor gaps around with_payload and with_vectors, but those are largely self-explanatory and the complex filter schema is documented inline.

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?

Schema description coverage is low, so the description must add meaning. It provides crucial semantics for offset, limit, and order_by paging, including offset rejection and start_from continuation, though it does not describe with_payload, with_vectors, or scroll_filter behavior in prose.

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 and resource: page through all points in a collection, optionally filtered. It is clear enough to distinguish scrolling from querying or getting individual points, though it does not explicitly name the sibling alternatives.

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

Usage Guidelines3/5

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

The description explains how to use paging via next_page_offset and when order_by changes paging behavior, but it does not explicitly say when to use this tool instead of qdrant_query, qdrant_points_get, or qdrant_points_count. Usage is implied rather than fully guided.

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

qdrant_points_upsertA

DestructiveIdempotent

Insert or replace points (id + vector + payload) in a collection.

    `vector` matches the collection's vector config: a plain list for a
    single unnamed vector; a list of lists for an unnamed multivector;
    or a dict keyed by vector name for named vectors, where each value
    is a dense list, a multivector, or a sparse vector
    (`{"indices": [...], "values": [...]}`).

    `update_mode` makes the write conditional: `insert_only` never
    overwrites an existing id, `update_only` never creates a new one
    (default `upsert` does both). `update_filter` only overwrites existing
    points whose current payload matches the filter. `wait=false`
    returns before the write is applied.

    Fails with a clear error if the collection doesn't exist.

    Example: {"collection_name": "docs", "points": [
        {"id": 1, "vector": [0.1, 0.2, 0.3, 0.4], "payload": {"city": "ny"}}
    ]}
    Example (named dense + sparse): {"collection_name": "docs", "points": [
        {"id": 1, "vector": {"dense": [0.1, 0.2, 0.3, 0.4],
            "sparse": {"indices": [1, 7], "values": [0.5, 0.2]}}}
    ]}

Name	Required	Description	Default
`wait`	No
`points`	Yes
`update_mode`	No
`update_filter`	No
`collection_name`	Yes

Output Schema

Name	Required	Description
`status`	Yes
`operation_id`	No	Sequential number of the operation

TDQS

A4.5/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 readOnlyHint=false, so the safety profile is known; the description adds genuine value on top by explaining the conditional write modes, the deferred-write behaviour of `wait=false`, and the failure mode when the collection is missing. What it does not resolve is the key destructive question for a replace operation: whether an existing point's payload is merged or wholly overwritten when the same id is upserted.

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 one-line purpose, then parameter semantics, then examples — a sensible ordering where every block earns its place. It is on the long side, and the two full JSON examples repeat structure that the prose above already conveyed, but the second example is what makes the named dense+sparse shape concrete.

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

Completeness5/5

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

For a five-parameter mutation tool with an output schema and rich annotations, the description covers everything an agent needs to call it correctly: vector shape selection, mode semantics, the deferral caveat, and the missing-collection error. Return values are handled by the output schema, so no gap remains.

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?

Top-level schema description coverage is effectively 0% for `vector`, so the description carries the burden and does so thoroughly — plain list for a single unnamed vector, list of lists for a multivector, dict keyed by vector name for named vectors with sparse `{indices, values}` support. It also defines each `update_mode` value and the meaning of `update_filter` and `wait=false`, with two worked examples covering the dense and the dense+sparse cases.

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?

States a specific verb pair and resource: 'Insert or replace points (id + vector + payload) in a collection.' The verb-plus-resource combination ('upsert points') is unambiguous against siblings like qdrant_points_get, qdrant_points_delete and qdrant_points_scroll, which perform entirely different operations on the same resource.

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 real conditional guidance on the modes: `insert_only` never overwrites an existing id, `update_only` never creates a new one, `update_filter` only overwrites matching points, and `wait=false` returns before the write is applied. It does not, however, tell the agent when to prefer a sibling tool (e.g. qdrant_points_delete for removals or qdrant_query for reads), so routing between tools is left to inference.

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

qdrant_queryA

Read-onlyIdempotent

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}

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
`points`	Yes

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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

7 tool updatesv2.6.0Oct 25, 2026

Changedqdrant_collection_create8 fields changed

removedInput schema / $defs

Removed value: -{
-  "BinaryQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "binary": {
-        "$ref": "#/$defs/BinaryQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "binary"
-    ],
-    "title": "BinaryQuantization",
-    "type": "object"
-  },
-  "BinaryQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "encoding": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/BinaryQuantizationEncoding"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      },
-      "query_encoding": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/BinaryQuantizationQueryEncoding"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Asymmetric quantization configuration allows a query to have different quantization than stored vectors. It can increase the accuracy of search at the cost of performance."
-      }
-    },
-    "title": "BinaryQuantizationConfig",
-    "type": "object"
-  },
-  "BinaryQuantizationEncoding": {
-    "enum": [
-      "one_bit",
-      "two_bits",
-      "one_and_half_bits"
-    ],
-    "title": "BinaryQuantizationEncoding",
-    "type": "string"
-  },
-  "BinaryQuantizationQueryEncoding": {
-    "enum": [
-      "default",
-      "binary",
-      "scalar4bits",
-      "scalar8bits"
-    ],
-    "title": "BinaryQuantizationQueryEncoding",
-    "type": "string"
-  },
-  "CompressionRatio": {
-    "enum": [
-      "x4",
-      "x8",
-      "x16",
-      "x32",
-      "x64"
-    ],
-    "title": "CompressionRatio",
-    "type": "string"
-  },
-  "Datatype": {
-    "enum": [
-      "float32",
-      "uint8",
-      "float16",
-      "turbo4"
-    ],
-    "title": "Datatype",
-    "type": "string"
-  },
-  "Distance": {
-    "description": "Type of internal tags, build from payload Distance function types used to compare vectors",
-    "enum": [
-      "Cosine",
-      "Euclid",
-      "Dot",
-      "Manhattan"
-    ],
-    "title": "Distance",
-    "type": "string"
-  },
-  "HnswConfigDiff": {
-    "additionalProperties": false,
-    "properties": {
-      "ef_construct": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build the index.",
-        "title": "Ef Construct"
-      },
-      "full_scan_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Minimal size threshold (in KiloBytes) below which full-scan is preferred over HNSW search. This measures the total size of vectors being queried against. When the maximum estimated amount of points that a condition satisfies is smaller than `full_scan_threshold_kb`, the query planner will use full-scan search instead of HNSW index traversal for better performance. Note: 1Kb = 1 vector of size 256",
-        "title": "Full Scan Threshold"
-      },
-      "inline_storage": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Store copies of original and quantized vectors within the HNSW index file. Default: false. Enabling this option will trade the search speed for disk usage by reducing amount of random seeks during the search. Requires quantized vectors to be enabled. Multi-vectors are not supported.",
-        "title": "Inline Storage"
-      },
-      "m": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.",
-        "title": "M"
-      },
-      "max_indexing_threads": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of building broken/inefficient HNSW graphs. On small CPUs, less threads are used.",
-        "title": "Max Indexing Threads"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the HNSW graph. Overrides the deprecated `on_disk` flag if both are set. Default: `cached` (`cold` if `on_disk` is set to true)."
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. Store HNSW index on disk. If set to false, the index will be stored in RAM. Default: false",
-        "title": "On Disk"
-      },
-      "payload_m": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom M param for additional payload-aware HNSW links. If not set, default M will be used.",
-        "title": "Payload M"
-      }
-    },
-    "title": "HnswConfigDiff",
-    "type": "object"
-  },
-  "Memory": {
-    "description": "Memory placement of a component&#x27;s data.  Data is always persisted on disk regardless of this setting; it only controls how the data is held in RAM.  Options:  * `Cold` - Data is not pre-loaded from disk to RAM. Preferred for rarely queried components or components larger than RAM size. First request might be slow, but data is cached with usage.  * `Cached` - Data is pre-loaded into disk-cache RAM on start. First request is fast, but data may be evicted if there is not enough memory and some other component&#x27;s data is used more frequently.  * `Pinned` - Data is loaded in RAM and never evicted. First request is fast, but the component must fit in RAM at all times. Recommended for frequently queried small components like quantized vectors or primary indexes.",
-    "enum": [
-      "cold",
-      "cached",
-      "pinned"
-    ],
-    "title": "Memory",
-    "type": "string"
-  },
-  "Modifier": {
-    "description": "If used, include weight modification, which will be applied to sparse vectors at query time: None - no modification (default) Idf - inverse document frequency, based on statistics of the collection",
-    "enum": [
-      "none",
-      "idf"
-    ],
-    "title": "Modifier",
-    "type": "string"
-  },
-  "MultiVectorComparator": {
-    "enum": [
-      "max_sim"
-    ],
-    "title": "MultiVectorComparator",
-    "type": "string"
-  },
-  "MultiVectorConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "comparator": {
-        "$ref": "#/$defs/MultiVectorComparator",
-        "description": ""
-      }
-    },
-    "required": [
-      "comparator"
-    ],
-    "title": "MultiVectorConfig",
-    "type": "object"
-  },
-  "ProductQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "product": {
-        "$ref": "#/$defs/ProductQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "product"
-    ],
-    "title": "ProductQuantization",
-    "type": "object"
-  },
-  "ProductQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "compression": {
-        "$ref": "#/$defs/CompressionRatio",
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      }
-    },
-    "required": [
-      "compression"
-    ],
-    "title": "ProductQuantizationConfig",
-    "type": "object"
-  },
-  "ScalarQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "scalar": {
-        "$ref": "#/$defs/ScalarQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "scalar"
-    ],
-    "title": "ScalarQuantization",
-    "type": "object"
-  },
-  "ScalarQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. If true - quantized vectors always will be stored in RAM, ignoring the config of main storage",
-        "title": "Always Ram"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      },
-      "quantile": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Quantile for quantization. Expected value range in [0.5, 1.0]. If not set - use the whole range of values",
-        "title": "Quantile"
-      },
-      "type": {
-        "$ref": "#/$defs/ScalarType",
-        "description": ""
-      }
-    },
-    "required": [
-      "type"
-    ],
-    "title": "ScalarQuantizationConfig",
-    "type": "object"
-  },
-  "ScalarType": {
-    "enum": [
-      "int8"
-    ],
-    "title": "ScalarType",
-    "type": "string"
-  },
-  "SparseIndexParams": {
-    "additionalProperties": false,
-    "description": "Configuration for sparse inverted index.",
-    "properties": {
-      "datatype": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Datatype"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy.  - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range."
-      },
-      "full_scan_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "We prefer a full scan search upto (excluding) this number of vectors.  Note: this is number of vectors, not KiloBytes.",
-        "title": "Full Scan Threshold"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the index. Overrides the deprecated `on_disk` flag if both are set. Default: `pinned` (`cold` if `on_disk` is set to true)."
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. Store index on disk. If set to false, the index will be stored in RAM. Default: false",
-        "title": "On Disk"
-      }
-    },
-    "title": "SparseIndexParams",
-    "type": "object"
-  },
-  "SparseVectorParams": {
-    "additionalProperties": false,
-    "description": "Params of single sparse vector data storage",
-    "properties": {
-      "index": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/SparseIndexParams"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom params for index. If none - values from collection configuration are used."
-      },
-      "modifier": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Modifier"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Configures addition value modifications for sparse vectors. Default: none"
-      }
-    },
-    "title": "SparseVectorParams",
-    "type": "object"
-  },
-  "StrictModeConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "condition_max_size": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a condition, eg. items in `MatchAny`.",
-        "title": "Condition Max Size"
-      },
-      "enabled": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Whether strict mode is enabled for a collection or not.",
-        "title": "Enabled"
-      },
-      "filter_max_conditions": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max conditions a filter can have.",
-        "title": "Filter Max Conditions"
-      },
-      "max_collection_payload_size_bytes": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a collections payload storage in bytes",
-        "title": "Max Collection Payload Size Bytes"
-      },
-      "max_collection_vector_size_bytes": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a collections vector storage in bytes, ignoring replicas.",
-        "title": "Max Collection Vector Size Bytes"
-      },
-      "max_payload_index_count": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of payload indexes in a collection",
-        "title": "Max Payload Index Count"
-      },
-      "max_points_count": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of points estimated in a collection",
-        "title": "Max Points Count"
-      },
-      "max_query_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max allowed `limit` parameter for all APIs that don&#x27;t have their own max limit.",
-        "title": "Max Query Limit"
-      },
-      "max_resident_memory_percent": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use the node-wide quota config (`PUT /quotas`) instead, which caps the same resource for every collection. Scheduled for removal in 1.21.  Reject memory-consuming update operations (e.g. upsert, set payload) when the process resident memory exceeds this percentage of total system memory (or cgroup limit). Value in [1, 100]. Memory is a node-wide resource, so this only tightens the quota for one collection; it cannot lift it. Delete operations are not affected, so callers can still free memory.",
-        "title": "Max Resident Memory Percent"
-      },
-      "max_timeout": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max allowed `timeout` parameter.",
-        "title": "Max Timeout"
-      },
-      "multivector_config": {
-        "anyOf": [
-          {
-            "additionalProperties": {
-              "$ref": "#/$defs/StrictModeMultivector"
-            },
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Multivector strict mode configuration",
-        "title": "Multivector Config"
-      },
-      "read_rate_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of read operations per minute per replica",
-        "title": "Read Rate Limit"
-      },
-      "search_allow_exact": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Whether exact search is allowed.",
-        "title": "Search Allow Exact"
-      },
-      "search_max_batchsize": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max batchsize when searching",
-        "title": "Search Max Batchsize"
-      },
-      "search_max_hnsw_ef": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max HNSW ef value allowed in search parameters.",
-        "title": "Search Max Hnsw Ef"
-      },
-      "search_max_oversampling": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max oversampling value allowed in search.",
-        "title": "Search Max Oversampling"
-      },
-      "sparse_config": {
-        "anyOf": [
-          {
-            "additionalProperties": {
-              "$ref": "#/$defs/StrictModeSparse"
-            },
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Sparse vector strict mode configuration",
-        "title": "Sparse Config"
-      },
-      "unindexed_filtering_retrieve": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Allow usage of unindexed fields in retrieval based (e.g. search) filters.",
-        "title": "Unindexed Filtering Retrieve"
-      },
-      "unindexed_filtering_update": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Allow usage of unindexed fields in filtered updates (e.g. delete by payload).",
-        "title": "Unindexed Filtering Update"
-      },
-      "upsert_max_batchsize": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max batchsize when upserting",
-        "title": "Upsert Max Batchsize"
-      },
-      "write_rate_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of write operations per minute per replica",
-        "title": "Write Rate Limit"
-      }
-    },
-    "title": "StrictModeConfig",
-    "type": "object"
-  },
-  "StrictModeMultivector": {
-    "additionalProperties": false,
-    "properties": {
-      "max_vectors": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of vectors in a multivector",
-        "title": "Max Vectors"
-      }
-    },
-    "title": "StrictModeMultivector",
-    "type": "object"
-  },
-  "StrictModeSparse": {
-    "additionalProperties": false,
-    "properties": {
-      "max_length": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max length of sparse vector",
-        "title": "Max Length"
-      }
-    },
-    "title": "StrictModeSparse",
-    "type": "object"
-  },
-  "TurboQuantBitSize": {
-    "enum": [
-      "bits1",
-      "bits1_5",
-      "bits2",
-      "bits4"
-    ],
-    "title": "TurboQuantBitSize",
-    "type": "string"
-  },
-  "TurboQuantQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "bits": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/TurboQuantBitSize"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      }
-    },
-    "title": "TurboQuantQuantizationConfig",
-    "type": "object"
-  },
-  "TurboQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "turbo": {
-        "$ref": "#/$defs/TurboQuantQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "turbo"
-    ],
-    "title": "TurboQuantization",
-    "type": "object"
-  },
-  "VectorParams": {
-    "additionalProperties": false,
-    "description": "Params of single vector data storage",
-    "properties": {
-      "datatype": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Datatype"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Defines which datatype should be used to represent vectors in the storage. Choosing different datatypes allows to optimize memory usage and performance vs accuracy.  - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are stored as unsigned 8-bit integers, 1 byte. It expects vector elements to be in range `[0, 255]`. - For `turbo4` datatype - vectors are quantized to 4 bits per element using the TurboQuant algorithm."
-      },
-      "distance": {
-        "$ref": "#/$defs/Distance",
-        "description": "Params of single vector data storage"
-      },
-      "hnsw_config": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/HnswConfigDiff"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom params for HNSW index. If none - values from collection configuration are used."
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the original vector storage. Overrides the deprecated `on_disk` flag if both are set. `pinned` is not supported for dense vector storage. Default: `cached` (`cold` if `on_disk` is set to true)."
-      },
-      "multivector_config": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/MultiVectorConfig"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Params of single vector data storage"
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. If true, vectors are served from disk, improving RAM usage at the cost of latency Default: false",
-        "title": "On Disk"
-      },
-      "quantization_config": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/ScalarQuantization"
-          },
-          {
-            "$ref": "#/$defs/ProductQuantization"
-          },
-          {
-            "$ref": "#/$defs/BinaryQuantization"
-          },
-          {
-            "$ref": "#/$defs/TurboQuantization"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom params for quantization. If none - values from collection configuration are used.",
-        "title": "Quantization Config"
-      },
-      "size": {
-        "description": "Size of a vectors used",
-        "title": "Size",
-        "type": "integer"
-      }
-    },
-    "required": [
-      "size",
-      "distance"
-    ],
-    "title": "VectorParams",
-    "type": "object"
-  }
-}

addedInput schema / properties / hnsw_config

Added value: +{
+  "anyOf": [
+    {
+      "additionalProperties": false,
+      "properties": {
+        "ef_construct": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "full_scan_threshold": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "inline_storage": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "m": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "max_indexing_threads": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "memory": {
+          "anyOf": [
+            {
+              "enum": [
+                "cold",
+                "cached",
+                "pinned"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "on_disk": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "payload_m": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null
+}

addedInput schema / properties / on_disk_payload

Added value: +{
+  "anyOf": [
+    {
+      "type": "boolean"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "On Disk Payload"
+}

addedInput schema / properties / optimizers_config

Added value: +{
+  "anyOf": [
+    {
+      "additionalProperties": false,
+      "properties": {
+        "default_segment_number": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "deleted_threshold": {
+          "anyOf": [
+            {
+              "type": "number"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "flush_interval_sec": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "indexing_threshold": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "max_optimization_threads": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "enum": [
+                "auto"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "max_segment_size": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "memmap_threshold": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "prevent_unoptimized": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "vacuum_min_vector_number": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null
+}

changedInput schema / properties / quantization_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/ScalarQuantization"
-  },
-  {
-    "$ref": "#/$defs/ProductQuantization"
-  },
-  {
-    "$ref": "#/$defs/BinaryQuantization"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "scalar": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "quantile": {
+            "anyOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "type": {
+            "enum": [
+              "int8"
+            ],
+            "type": "string"
+          }
+        },
+        "required": [
+          "type"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "scalar"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "product": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "compression": {
+            "enum": [
+              "x4",
+              "x8",
+              "x16",
+              "x32",
+              "x64"
+            ],
+            "type": "string"
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": [
+          "compression"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "product"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "binary": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "encoding": {
+            "anyOf": [
+              {
+                "enum": [
+                  "one_bit",
+                  "two_bits",
+                  "one_and_half_bits"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "query_encoding": {
+            "anyOf": [
+              {
+                "enum": [
+                  "default",
+                  "binary",
+                  "scalar4bits",
+                  "scalar8bits"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "type": "object"
+      }
+    },
+    "required": [
+      "binary"
+    ],
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / sparse_vectors / anyOf

Previous value: -[
-  {
-    "additionalProperties": {
-      "$ref": "#/$defs/SparseVectorParams"
-    },
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": {
+      "additionalProperties": false,
+      "properties": {
+        "index": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "datatype": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "float32",
+                        "uint8",
+                        "float16",
+                        "turbo4"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "full_scan_threshold": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "memory": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "cold",
+                        "cached",
+                        "pinned"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "on_disk": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "modifier": {
+          "anyOf": [
+            {
+              "enum": [
+                "none",
+                "idf"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / strict_mode_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/StrictModeConfig"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "condition_max_size": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "enabled": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "filter_max_conditions": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_collection_payload_size_bytes": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_collection_vector_size_bytes": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_payload_index_count": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_points_count": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_query_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_resident_memory_percent": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_timeout": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "multivector_config": {
+        "anyOf": [
+          {
+            "additionalProperties": {
+              "additionalProperties": false,
+              "properties": {
+                "max_vectors": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "read_rate_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_allow_exact": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_batchsize": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_hnsw_ef": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_oversampling": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "sparse_config": {
+        "anyOf": [
+          {
+            "additionalProperties": {
+              "additionalProperties": false,
+              "properties": {
+                "max_length": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "unindexed_filtering_retrieve": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "unindexed_filtering_update": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "upsert_max_batchsize": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "write_rate_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / vectors / anyOf

Previous value: -[
-  {
-    "additionalProperties": {
-      "$ref": "#/$defs/VectorParams"
-    },
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": {
+      "additionalProperties": false,
+      "properties": {
+        "datatype": {
+          "anyOf": [
+            {
+              "enum": [
+                "float32",
+                "uint8",
+                "float16",
+                "turbo4"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "distance": {
+          "enum": [
+            "Cosine",
+            "Euclid",
+            "Dot",
+            "Manhattan"
+          ],
+          "type": "string"
+        },
+        "hnsw_config": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "ef_construct": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "full_scan_threshold": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "inline_storage": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "m": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "max_indexing_threads": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "memory": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "cold",
+                        "cached",
+                        "pinned"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "on_disk": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "payload_m": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "memory": {
+          "anyOf": [
+            {
+              "enum": [
+                "cold",
+                "cached",
+                "pinned"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "multivector_config": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "comparator": {
+                  "enum": [
+                    "max_sim"
+                  ],
+                  "type": "string"
+                }
+              },
+              "required": [
+                "comparator"
+              ],
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "on_disk": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "quantization_config": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "scalar": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "quantile": {
+                      "anyOf": [
+                        {
+                          "type": "number"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "type": {
+                      "enum": [
+                        "int8"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "type"
+                  ],
+                  "type": "object"
+                }
+              },
+              "required": [
+                "scalar"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "product": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "compression": {
+                      "enum": [
+                        "x4",
+                        "x8",
+                        "x16",
+                        "x32",
+                        "x64"
+                      ],
+                      "type": "string"
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "required": [
+                    "compression"
+                  ],
+                  "type": "object"
+                }
+              },
+              "required": [
+                "product"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "binary": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "encoding": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "one_bit",
+                            "two_bits",
+                            "one_and_half_bits"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "query_encoding": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "default",
+                            "binary",
+                            "scalar4bits",
+                            "scalar8bits"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "type": "object"
+                }
+              },
+              "required": [
+                "binary"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "turbo": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "bits": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "bits1",
+                            "bits1_5",
+                            "bits2",
+                            "bits4"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "type": "object"
+                }
+              },
+              "required": [
+                "turbo"
+              ],
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "size": {
+          "type": "integer"
+        }
+      },
+      "required": [
+        "size",
+        "distance"
+      ],
+      "type": "object"
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedqdrant_collection_update8 fields changed

removedInput schema / $defs

Removed value: -{
-  "BinaryQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "binary": {
-        "$ref": "#/$defs/BinaryQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "binary"
-    ],
-    "title": "BinaryQuantization",
-    "type": "object"
-  },
-  "BinaryQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "encoding": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/BinaryQuantizationEncoding"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      },
-      "query_encoding": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/BinaryQuantizationQueryEncoding"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Asymmetric quantization configuration allows a query to have different quantization than stored vectors. It can increase the accuracy of search at the cost of performance."
-      }
-    },
-    "title": "BinaryQuantizationConfig",
-    "type": "object"
-  },
-  "BinaryQuantizationEncoding": {
-    "enum": [
-      "one_bit",
-      "two_bits",
-      "one_and_half_bits"
-    ],
-    "title": "BinaryQuantizationEncoding",
-    "type": "string"
-  },
-  "BinaryQuantizationQueryEncoding": {
-    "enum": [
-      "default",
-      "binary",
-      "scalar4bits",
-      "scalar8bits"
-    ],
-    "title": "BinaryQuantizationQueryEncoding",
-    "type": "string"
-  },
-  "CollectionParamsDiff": {
-    "additionalProperties": false,
-    "properties": {
-      "on_disk_payload": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `payload.memory` instead. If true - point&#x27;s payload will not be stored in memory. It will be read from the disk every time it is requested. This setting saves RAM by (slightly) increasing the response time. Note: those payload values that are involved in filtering and are indexed - remain in RAM.",
-        "title": "On Disk Payload"
-      },
-      "payload": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/PayloadStorageParams"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Update params of the payload storage. If none - it is left unchanged."
-      },
-      "read_fan_out_delay_ms": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Delay in milliseconds before sending read requests to remote nodes",
-        "title": "Read Fan Out Delay Ms"
-      },
-      "read_fan_out_factor": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Fan-out every read request to these many additional remote nodes (and return first available response)",
-        "title": "Read Fan Out Factor"
-      },
-      "replication_factor": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of replicas for each shard",
-        "title": "Replication Factor"
-      },
-      "write_consistency_factor": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Minimal number successful responses from replicas to consider operation successful",
-        "title": "Write Consistency Factor"
-      }
-    },
-    "title": "CollectionParamsDiff",
-    "type": "object"
-  },
-  "CompressionRatio": {
-    "enum": [
-      "x4",
-      "x8",
-      "x16",
-      "x32",
-      "x64"
-    ],
-    "title": "CompressionRatio",
-    "type": "string"
-  },
-  "Datatype": {
-    "enum": [
-      "float32",
-      "uint8",
-      "float16",
-      "turbo4"
-    ],
-    "title": "Datatype",
-    "type": "string"
-  },
-  "Disabled": {
-    "enum": [
-      "Disabled"
-    ],
-    "title": "Disabled",
-    "type": "string"
-  },
-  "HnswConfigDiff": {
-    "additionalProperties": false,
-    "properties": {
-      "ef_construct": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build the index.",
-        "title": "Ef Construct"
-      },
-      "full_scan_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Minimal size threshold (in KiloBytes) below which full-scan is preferred over HNSW search. This measures the total size of vectors being queried against. When the maximum estimated amount of points that a condition satisfies is smaller than `full_scan_threshold_kb`, the query planner will use full-scan search instead of HNSW index traversal for better performance. Note: 1Kb = 1 vector of size 256",
-        "title": "Full Scan Threshold"
-      },
-      "inline_storage": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Store copies of original and quantized vectors within the HNSW index file. Default: false. Enabling this option will trade the search speed for disk usage by reducing amount of random seeks during the search. Requires quantized vectors to be enabled. Multi-vectors are not supported.",
-        "title": "Inline Storage"
-      },
-      "m": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.",
-        "title": "M"
-      },
-      "max_indexing_threads": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Number of parallel threads used for background index building. If 0 - automatically select from 8 to 16. Best to keep between 8 and 16 to prevent likelihood of building broken/inefficient HNSW graphs. On small CPUs, less threads are used.",
-        "title": "Max Indexing Threads"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the HNSW graph. Overrides the deprecated `on_disk` flag if both are set. Default: `cached` (`cold` if `on_disk` is set to true)."
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. Store HNSW index on disk. If set to false, the index will be stored in RAM. Default: false",
-        "title": "On Disk"
-      },
-      "payload_m": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom M param for additional payload-aware HNSW links. If not set, default M will be used.",
-        "title": "Payload M"
-      }
-    },
-    "title": "HnswConfigDiff",
-    "type": "object"
-  },
-  "MaxOptimizationThreadsSetting": {
-    "enum": [
-      "auto"
-    ],
-    "title": "MaxOptimizationThreadsSetting",
-    "type": "string"
-  },
-  "Memory": {
-    "description": "Memory placement of a component&#x27;s data.  Data is always persisted on disk regardless of this setting; it only controls how the data is held in RAM.  Options:  * `Cold` - Data is not pre-loaded from disk to RAM. Preferred for rarely queried components or components larger than RAM size. First request might be slow, but data is cached with usage.  * `Cached` - Data is pre-loaded into disk-cache RAM on start. First request is fast, but data may be evicted if there is not enough memory and some other component&#x27;s data is used more frequently.  * `Pinned` - Data is loaded in RAM and never evicted. First request is fast, but the component must fit in RAM at all times. Recommended for frequently queried small components like quantized vectors or primary indexes.",
-    "enum": [
-      "cold",
-      "cached",
-      "pinned"
-    ],
-    "title": "Memory",
-    "type": "string"
-  },
-  "Modifier": {
-    "description": "If used, include weight modification, which will be applied to sparse vectors at query time: None - no modification (default) Idf - inverse document frequency, based on statistics of the collection",
-    "enum": [
-      "none",
-      "idf"
-    ],
-    "title": "Modifier",
-    "type": "string"
-  },
-  "OptimizersConfigDiff": {
-    "additionalProperties": false,
-    "properties": {
-      "default_segment_number": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Target amount of segments optimizer will try to keep. Real amount of segments may vary depending on multiple parameters: - Amount of stored points - Current write RPS  It is recommended to select default number of segments as a factor of the number of search threads, so that each segment would be handled evenly by one of the threads If `default_segment_number = 0`, will be automatically selected by the number of available CPUs",
-        "title": "Default Segment Number"
-      },
-      "deleted_threshold": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "The minimal fraction of deleted vectors in a segment, required to perform segment optimization",
-        "title": "Deleted Threshold"
-      },
-      "flush_interval_sec": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Minimum interval between forced flushes.",
-        "title": "Flush Interval Sec"
-      },
-      "indexing_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Maximum size (in kilobytes) of vectors allowed for plain index, exceeding this threshold will enable vector indexing  Default value is 20,000, based on &lt;https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md&gt;.  To disable vector indexing, set to `0`.  Note: 1kB = 1 vector of size 256.",
-        "title": "Indexing Threshold"
-      },
-      "max_optimization_threads": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "$ref": "#/$defs/MaxOptimizationThreadsSetting"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of threads (jobs) for running optimizations per shard. Note: each optimization job will also use `max_indexing_threads` threads by itself for index building. If &quot;auto&quot; - have no limit and choose dynamically to saturate CPU. If 0 - no optimization threads, optimizations will be disabled.",
-        "title": "Max Optimization Threads"
-      },
-      "max_segment_size": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Do not create segments larger this size (in kilobytes). Large segments might require disproportionately long indexation times, therefore it makes sense to limit the size of segments.  If indexation speed have more priority for your - make this parameter lower. If search speed is more important - make this parameter higher. Note: 1Kb = 1 vector of size 256",
-        "title": "Max Segment Size"
-      },
-      "memmap_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Maximum size (in kilobytes) of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmapped file.  Memmap storage is disabled by default, to enable it, set this threshold to a reasonable value.  To disable memmap storage, set this to `0`.  Note: 1Kb = 1 vector of size 256  Deprecated since Qdrant 1.15.0",
-        "title": "Memmap Threshold"
-      },
-      "prevent_unoptimized": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "If enabled, the service will try to prevent the creation of large unoptimized segments. When enabled, new points written to segments larger than the indexing threshold are stored as 'deferred points': they are persisted in the WAL and segments, but excluded from read/search results until the corresponding segments are optimized (e.g. indexed, quantized, or moved to mmap storage). Update requests with `wait=true` will only return after the deferred points become visible, which may significantly increase the perceived latency between submitting an update and its completion. Update requests with `wait=false` are not affected. Default is disabled.",
-        "title": "Prevent Unoptimized"
-      },
-      "vacuum_min_vector_number": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "The minimal number of vectors in a segment, required to perform segment optimization",
-        "title": "Vacuum Min Vector Number"
-      }
-    },
-    "title": "OptimizersConfigDiff",
-    "type": "object"
-  },
-  "PayloadStorageParams": {
-    "additionalProperties": false,
-    "description": "Params of the payload storage",
-    "properties": {
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the payload storage. Overrides the deprecated `on_disk_payload` flag if both are set. `pinned` is not supported for payload storage. Default: `cold` (`cached` if `on_disk_payload` is set to false)."
-      }
-    },
-    "title": "PayloadStorageParams",
-    "type": "object"
-  },
-  "ProductQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "product": {
-        "$ref": "#/$defs/ProductQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "product"
-    ],
-    "title": "ProductQuantization",
-    "type": "object"
-  },
-  "ProductQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "compression": {
-        "$ref": "#/$defs/CompressionRatio",
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      }
-    },
-    "required": [
-      "compression"
-    ],
-    "title": "ProductQuantizationConfig",
-    "type": "object"
-  },
-  "ScalarQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "scalar": {
-        "$ref": "#/$defs/ScalarQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "scalar"
-    ],
-    "title": "ScalarQuantization",
-    "type": "object"
-  },
-  "ScalarQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. If true - quantized vectors always will be stored in RAM, ignoring the config of main storage",
-        "title": "Always Ram"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      },
-      "quantile": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Quantile for quantization. Expected value range in [0.5, 1.0]. If not set - use the whole range of values",
-        "title": "Quantile"
-      },
-      "type": {
-        "$ref": "#/$defs/ScalarType",
-        "description": ""
-      }
-    },
-    "required": [
-      "type"
-    ],
-    "title": "ScalarQuantizationConfig",
-    "type": "object"
-  },
-  "ScalarType": {
-    "enum": [
-      "int8"
-    ],
-    "title": "ScalarType",
-    "type": "string"
-  },
-  "SparseIndexParams": {
-    "additionalProperties": false,
-    "description": "Configuration for sparse inverted index.",
-    "properties": {
-      "datatype": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Datatype"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Defines which datatype should be used for the index. Choosing different datatypes allows to optimize memory usage and performance vs accuracy.  - For `float32` datatype - vectors are stored as single-precision floating point numbers, 4 bytes. - For `float16` datatype - vectors are stored as half-precision floating point numbers, 2 bytes. - For `uint8` datatype - vectors are quantized to unsigned 8-bit integers, 1 byte. Quantization to fit byte range `[0, 255]` happens during indexing automatically, so the actual vector data does not need to conform to this range."
-      },
-      "full_scan_threshold": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "We prefer a full scan search upto (excluding) this number of vectors.  Note: this is number of vectors, not KiloBytes.",
-        "title": "Full Scan Threshold"
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the index. Overrides the deprecated `on_disk` flag if both are set. Default: `pinned` (`cold` if `on_disk` is set to true)."
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. Store index on disk. If set to false, the index will be stored in RAM. Default: false",
-        "title": "On Disk"
-      }
-    },
-    "title": "SparseIndexParams",
-    "type": "object"
-  },
-  "SparseVectorParams": {
-    "additionalProperties": false,
-    "description": "Params of single sparse vector data storage",
-    "properties": {
-      "index": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/SparseIndexParams"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Custom params for index. If none - values from collection configuration are used."
-      },
-      "modifier": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Modifier"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Configures addition value modifications for sparse vectors. Default: none"
-      }
-    },
-    "title": "SparseVectorParams",
-    "type": "object"
-  },
-  "StrictModeConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "condition_max_size": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a condition, eg. items in `MatchAny`.",
-        "title": "Condition Max Size"
-      },
-      "enabled": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Whether strict mode is enabled for a collection or not.",
-        "title": "Enabled"
-      },
-      "filter_max_conditions": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max conditions a filter can have.",
-        "title": "Filter Max Conditions"
-      },
-      "max_collection_payload_size_bytes": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a collections payload storage in bytes",
-        "title": "Max Collection Payload Size Bytes"
-      },
-      "max_collection_vector_size_bytes": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max size of a collections vector storage in bytes, ignoring replicas.",
-        "title": "Max Collection Vector Size Bytes"
-      },
-      "max_payload_index_count": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of payload indexes in a collection",
-        "title": "Max Payload Index Count"
-      },
-      "max_points_count": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of points estimated in a collection",
-        "title": "Max Points Count"
-      },
-      "max_query_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max allowed `limit` parameter for all APIs that don&#x27;t have their own max limit.",
-        "title": "Max Query Limit"
-      },
-      "max_resident_memory_percent": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use the node-wide quota config (`PUT /quotas`) instead, which caps the same resource for every collection. Scheduled for removal in 1.21.  Reject memory-consuming update operations (e.g. upsert, set payload) when the process resident memory exceeds this percentage of total system memory (or cgroup limit). Value in [1, 100]. Memory is a node-wide resource, so this only tightens the quota for one collection; it cannot lift it. Delete operations are not affected, so callers can still free memory.",
-        "title": "Max Resident Memory Percent"
-      },
-      "max_timeout": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max allowed `timeout` parameter.",
-        "title": "Max Timeout"
-      },
-      "multivector_config": {
-        "anyOf": [
-          {
-            "additionalProperties": {
-              "$ref": "#/$defs/StrictModeMultivector"
-            },
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Multivector strict mode configuration",
-        "title": "Multivector Config"
-      },
-      "read_rate_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of read operations per minute per replica",
-        "title": "Read Rate Limit"
-      },
-      "search_allow_exact": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Whether exact search is allowed.",
-        "title": "Search Allow Exact"
-      },
-      "search_max_batchsize": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max batchsize when searching",
-        "title": "Search Max Batchsize"
-      },
-      "search_max_hnsw_ef": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max HNSW ef value allowed in search parameters.",
-        "title": "Search Max Hnsw Ef"
-      },
-      "search_max_oversampling": {
-        "anyOf": [
-          {
-            "type": "number"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max oversampling value allowed in search.",
-        "title": "Search Max Oversampling"
-      },
-      "sparse_config": {
-        "anyOf": [
-          {
-            "additionalProperties": {
-              "$ref": "#/$defs/StrictModeSparse"
-            },
-            "type": "object"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Sparse vector strict mode configuration",
-        "title": "Sparse Config"
-      },
-      "unindexed_filtering_retrieve": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Allow usage of unindexed fields in retrieval based (e.g. search) filters.",
-        "title": "Unindexed Filtering Retrieve"
-      },
-      "unindexed_filtering_update": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Allow usage of unindexed fields in filtered updates (e.g. delete by payload).",
-        "title": "Unindexed Filtering Update"
-      },
-      "upsert_max_batchsize": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max batchsize when upserting",
-        "title": "Upsert Max Batchsize"
-      },
-      "write_rate_limit": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of write operations per minute per replica",
-        "title": "Write Rate Limit"
-      }
-    },
-    "title": "StrictModeConfig",
-    "type": "object"
-  },
-  "StrictModeMultivector": {
-    "additionalProperties": false,
-    "properties": {
-      "max_vectors": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max number of vectors in a multivector",
-        "title": "Max Vectors"
-      }
-    },
-    "title": "StrictModeMultivector",
-    "type": "object"
-  },
-  "StrictModeSparse": {
-    "additionalProperties": false,
-    "properties": {
-      "max_length": {
-        "anyOf": [
-          {
-            "type": "integer"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Max length of sparse vector",
-        "title": "Max Length"
-      }
-    },
-    "title": "StrictModeSparse",
-    "type": "object"
-  },
-  "TurboQuantBitSize": {
-    "enum": [
-      "bits1",
-      "bits1_5",
-      "bits2",
-      "bits4"
-    ],
-    "title": "TurboQuantBitSize",
-    "type": "string"
-  },
-  "TurboQuantQuantizationConfig": {
-    "additionalProperties": false,
-    "properties": {
-      "always_ram": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead.",
-        "title": "Always Ram"
-      },
-      "bits": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/TurboQuantBitSize"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": ""
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of quantized vectors. Overrides the deprecated `always_ram` flag if both are set. Default: follow the memory placement of the original vector storage."
-      }
-    },
-    "title": "TurboQuantQuantizationConfig",
-    "type": "object"
-  },
-  "TurboQuantization": {
-    "additionalProperties": false,
-    "properties": {
-      "turbo": {
-        "$ref": "#/$defs/TurboQuantQuantizationConfig",
-        "description": ""
-      }
-    },
-    "required": [
-      "turbo"
-    ],
-    "title": "TurboQuantization",
-    "type": "object"
-  },
-  "VectorParamsDiff": {
-    "additionalProperties": false,
-    "properties": {
-      "hnsw_config": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/HnswConfigDiff"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Update params for HNSW index. If empty object - it will be unset."
-      },
-      "memory": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/Memory"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Memory placement of the original vector storage. Overrides the deprecated `on_disk` flag if both are set. `pinned` is not supported for dense vector storage."
-      },
-      "on_disk": {
-        "anyOf": [
-          {
-            "type": "boolean"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Deprecated: use `memory` instead. If true, vectors are served from disk, improving RAM usage at the cost of latency",
-        "title": "On Disk"
-      },
-      "quantization_config": {
-        "anyOf": [
-          {
-            "$ref": "#/$defs/ScalarQuantization"
-          },
-          {
-            "$ref": "#/$defs/ProductQuantization"
-          },
-          {
-            "$ref": "#/$defs/BinaryQuantization"
-          },
-          {
-            "$ref": "#/$defs/TurboQuantization"
-          },
-          {
-            "$ref": "#/$defs/Disabled"
-          },
-          {
-            "type": "null"
-          }
-        ],
-        "default": null,
-        "description": "Update params for quantization. If none - it is left unchanged.",
-        "title": "Quantization Config"
-      }
-    },
-    "title": "VectorParamsDiff",
-    "type": "object"
-  }
-}

changedInput schema / properties / collection_params / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/CollectionParamsDiff"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "on_disk_payload": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "payload": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "properties": {
+              "memory": {
+                "anyOf": [
+                  {
+                    "enum": [
+                      "cold",
+                      "cached",
+                      "pinned"
+                    ],
+                    "type": "string"
+                  },
+                  {
+                    "type": "null"
+                  }
+                ]
+              }
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "read_fan_out_delay_ms": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "read_fan_out_factor": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "replication_factor": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "write_consistency_factor": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / hnsw_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/HnswConfigDiff"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "ef_construct": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "full_scan_threshold": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "inline_storage": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "m": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_indexing_threads": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "memory": {
+        "anyOf": [
+          {
+            "enum": [
+              "cold",
+              "cached",
+              "pinned"
+            ],
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "on_disk": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "payload_m": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / optimizers_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/OptimizersConfigDiff"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "default_segment_number": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "deleted_threshold": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "flush_interval_sec": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "indexing_threshold": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_optimization_threads": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "enum": [
+              "auto"
+            ],
+            "type": "string"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_segment_size": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "memmap_threshold": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "prevent_unoptimized": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "vacuum_min_vector_number": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / quantization_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/ScalarQuantization"
-  },
-  {
-    "$ref": "#/$defs/ProductQuantization"
-  },
-  {
-    "$ref": "#/$defs/BinaryQuantization"
-  },
-  {
-    "const": "disabled",
-    "type": "string"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "scalar": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "quantile": {
+            "anyOf": [
+              {
+                "type": "number"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "type": {
+            "enum": [
+              "int8"
+            ],
+            "type": "string"
+          }
+        },
+        "required": [
+          "type"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "scalar"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "product": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "compression": {
+            "enum": [
+              "x4",
+              "x8",
+              "x16",
+              "x32",
+              "x64"
+            ],
+            "type": "string"
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "required": [
+          "compression"
+        ],
+        "type": "object"
+      }
+    },
+    "required": [
+      "product"
+    ],
+    "type": "object"
+  },
+  {
+    "additionalProperties": false,
+    "properties": {
+      "binary": {
+        "additionalProperties": false,
+        "properties": {
+          "always_ram": {
+            "anyOf": [
+              {
+                "type": "boolean"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "encoding": {
+            "anyOf": [
+              {
+                "enum": [
+                  "one_bit",
+                  "two_bits",
+                  "one_and_half_bits"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "memory": {
+            "anyOf": [
+              {
+                "enum": [
+                  "cold",
+                  "cached",
+                  "pinned"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          },
+          "query_encoding": {
+            "anyOf": [
+              {
+                "enum": [
+                  "default",
+                  "binary",
+                  "scalar4bits",
+                  "scalar8bits"
+                ],
+                "type": "string"
+              },
+              {
+                "type": "null"
+              }
+            ]
+          }
+        },
+        "type": "object"
+      }
+    },
+    "required": [
+      "binary"
+    ],
+    "type": "object"
+  },
+  {
+    "const": "disabled",
+    "type": "string"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / sparse_vectors_config / anyOf

Previous value: -[
-  {
-    "additionalProperties": {
-      "$ref": "#/$defs/SparseVectorParams"
-    },
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": {
+      "additionalProperties": false,
+      "properties": {
+        "index": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "datatype": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "float32",
+                        "uint8",
+                        "float16",
+                        "turbo4"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "full_scan_threshold": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "memory": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "cold",
+                        "cached",
+                        "pinned"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "on_disk": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "modifier": {
+          "anyOf": [
+            {
+              "enum": [
+                "none",
+                "idf"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / strict_mode_config / anyOf

Previous value: -[
-  {
-    "$ref": "#/$defs/StrictModeConfig"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": false,
+    "properties": {
+      "condition_max_size": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "enabled": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "filter_max_conditions": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_collection_payload_size_bytes": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_collection_vector_size_bytes": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_payload_index_count": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_points_count": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_query_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_resident_memory_percent": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "max_timeout": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "multivector_config": {
+        "anyOf": [
+          {
+            "additionalProperties": {
+              "additionalProperties": false,
+              "properties": {
+                "max_vectors": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "read_rate_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_allow_exact": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_batchsize": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_hnsw_ef": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "search_max_oversampling": {
+        "anyOf": [
+          {
+            "type": "number"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "sparse_config": {
+        "anyOf": [
+          {
+            "additionalProperties": {
+              "additionalProperties": false,
+              "properties": {
+                "max_length": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            "type": "object"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "unindexed_filtering_retrieve": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "unindexed_filtering_update": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "upsert_max_batchsize": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      },
+      "write_rate_limit": {
+        "anyOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "null"
+          }
+        ]
+      }
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

changedInput schema / properties / vectors_config / anyOf

Previous value: -[
-  {
-    "additionalProperties": {
-      "$ref": "#/$defs/VectorParamsDiff"
-    },
-    "type": "object"
-  },
-  {
-    "type": "null"
-  }
-]New value: +[
+  {
+    "additionalProperties": {
+      "additionalProperties": false,
+      "properties": {
+        "hnsw_config": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "ef_construct": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "full_scan_threshold": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "inline_storage": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "m": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "max_indexing_threads": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "memory": {
+                  "anyOf": [
+                    {
+                      "enum": [
+                        "cold",
+                        "cached",
+                        "pinned"
+                      ],
+                      "type": "string"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "on_disk": {
+                  "anyOf": [
+                    {
+                      "type": "boolean"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                },
+                "payload_m": {
+                  "anyOf": [
+                    {
+                      "type": "integer"
+                    },
+                    {
+                      "type": "null"
+                    }
+                  ]
+                }
+              },
+              "type": "object"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "memory": {
+          "anyOf": [
+            {
+              "enum": [
+                "cold",
+                "cached",
+                "pinned"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "on_disk": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        },
+        "quantization_config": {
+          "anyOf": [
+            {
+              "additionalProperties": false,
+              "properties": {
+                "scalar": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "quantile": {
+                      "anyOf": [
+                        {
+                          "type": "number"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "type": {
+                      "enum": [
+                        "int8"
+                      ],
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "type"
+                  ],
+                  "type": "object"
+                }
+              },
+              "required": [
+                "scalar"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "product": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "compression": {
+                      "enum": [
+                        "x4",
+                        "x8",
+                        "x16",
+                        "x32",
+                        "x64"
+                      ],
+                      "type": "string"
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "required": [
+                    "compression"
+                  ],
+                  "type": "object"
+                }
+              },
+              "required": [
+                "product"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "binary": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "encoding": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "one_bit",
+                            "two_bits",
+                            "one_and_half_bits"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "query_encoding": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "default",
+                            "binary",
+                            "scalar4bits",
+                            "scalar8bits"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "type": "object"
+                }
+              },
+              "required": [
+                "binary"
+              ],
+              "type": "object"
+            },
+            {
+              "additionalProperties": false,
+              "properties": {
+                "turbo": {
+                  "additionalProperties": false,
+                  "properties": {
+                    "always_ram": {
+                      "anyOf": [
+                        {
+                          "type": "boolean"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "bits": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "bits1",
+                            "bits1_5",
+                            "bits2",
+                            "bits4"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    },
+                    "memory": {
+                      "anyOf": [
+                        {
+                          "enum": [
+                            "cold",
+                            "cached",
+                            "pinned"
+                          ],
+                          "type": "string"
+                        },
+                        {
+                          "type": "null"
+                        }
+                      ]
+                    }
+                  },
+                  "type": "object"
+                }
+              },
+              "required": [
+                "turbo"
+              ],
+              "type": "object"
+            },
+            {
+              "enum": [
+                "Disabled"
+              ],
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "type": "object"
+    },
+    "type": "object"
+  },
+  {
+    "type": "null"
+  }
+]

Changedqdrant_points_count2 fields changed

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 / count_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"
+  }
+]

Changedqdrant_points_delete2 fields changed

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

Changedqdrant_points_scroll31 fields changed

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

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

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

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

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

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 / properties / order_by

Added value: +{
+  "anyOf": [
+    {
+      "$ref": "#/$defs/OrderBy"
+    },
+    {
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Order By"
+}

changedInput schema / properties / scroll_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"
+  }
+]

Changedqdrant_points_upsert9 fields changed

addedInput schema / $defs / PointInput / additionalProperties
```
Added value: +false
```

changedInput schema / $defs / PointInput / description

Previous value: -"A point to upsert: a plain id + vector + payload — never `Document`,\n`Image`, or `InferenceObject` (qdrant-client's server-side embedding\ninference variants), which would contradict this server's principle of\nnever generating embeddings itself."New value: +"A point to upsert: id + vector(s) + payload. See `PointVectorValue`\nfor the accepted vector shapes."

addedInput schema / $defs / PointInput / properties / vector / anyOf

Added value: +[
+  {
+    "items": {
+      "type": "number"
+    },
+    "type": "array"
+  },
+  {
+    "items": {
+      "items": {
+        "type": "number"
+      },
+      "type": "array"
+    },
+    "type": "array"
+  },
+  {
+    "additionalProperties": {
+      "anyOf": [
+        {
+          "items": {
+            "type": "number"
+          },
+          "type": "array"
+        },
+        {
+          "$ref": "#/$defs/SparseVector"
+        },
+        {
+          "items": {
+            "items": {
+              "type": "number"
+            },
+            "type": "array"
+          },
+          "type": "array"
+        }
+      ]
+    },
+    "type": "object"
+  }
+]

removedInput schema / $defs / PointInput / properties / vector / items
```
Removed value: -{
-  "type": "number"
-}
```
removedInput schema / $defs / PointInput / properties / vector / type
```
Removed value: -"array"
```

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

addedInput schema / properties / update_filter

Added value: +{
+  "anyOf": [
+    {
+      "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"
+    }
+  ],
+  "default": null
+}

addedInput schema / properties / update_mode

Added value: +{
+  "anyOf": [
+    {
+      "enum": [
+        "upsert",
+        "insert_only",
+        "update_only"
+      ],
+      "type": "string"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "title": "Update Mode"
+}

addedInput schema / properties / wait

Added value: +{
+  "default": true,
+  "title": "Wait",
+  "type": "boolean"
+}

Changedqdrant_query56 fields changed

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

13 tool updatesv1.1.1Sep 1, 2026
- First observedqdrant_collection_create
- First observedqdrant_collection_delete
- First observedqdrant_collection_exists
- First observedqdrant_collection_info
- First observedqdrant_collection_list
- First observedqdrant_collection_update
- First observedqdrant_health_check
- First observedqdrant_points_count
- First observedqdrant_points_delete
- First observedqdrant_points_get
- First observedqdrant_points_scroll
- First observedqdrant_points_upsert
- First observedqdrant_query

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.9/5.0

Scored 2026-10-25 23:25 across 13 tools

Disambiguation4/5

Most tools have clearly distinct scopes: collection lifecycle, point CRUD, querying, and health checks are separated cleanly. A few boundaries are slightly fuzzy, especially qdrant_query with order_by/sample versus qdrant_points_scroll with order_by, and qdrant_points_get by id versus querying by point id, but the descriptions make the intended use reasonably clear.

Naming Consistency5/5

All tools follow a predictable qdrant_* snake_case convention with resource-oriented names such as qdrant_collection_create and qdrant_points_upsert. The few non-resource names like qdrant_query and qdrant_health_check still fit the same overall pattern.

Tool Count5/5

The set has 13 tools, which is well-scoped for a Qdrant MCP server. Each tool covers a distinct collection, point, query, or health operation without obvious redundancy.

Completeness4/5

The surface covers the core Qdrant lifecycle: collection list/create/update/delete/exists/info, point get/delete/upsert/scroll/count, query, and health. Minor gaps remain around payload index management, aliases/snapshots, and partial payload updates, but core workflows are covered.

Maintenance

ActivityActive

ResponsivenessNo issues

Resources

Related MCP Connectors

aicharged.ioOAuth
io.aicharged
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
Image & Video Processing Audio Processing Cloud Platforms
1
https://aicharged.io/api/v1/mcp
Astra DBOAuth
io.github.erichare
Astra DB tools for agents: schema, find, vector search, guarded writes, and interactive views.
Databases Vector Databases
1
https://astra-widgets-mcp.vercel.app/mcp
mcp
com.skopik
Your org's AI agents, tasks, runs, search, and brain files as MCP tools and resources.
Agent Orchestration Knowledge & Memory Search
2
https://api.skopik.com/mcp
khiveOAuth
ai.khive
Persistent memory, knowledge graph, task management and more for AI agents via MCP.
Knowledge & Memory Project Management
1
https://khive.ai/v1/mcp

Related MCP Servers

Pinecone MCP Server
Vector Databases RAG Systems Search
Solaceking
F
license
Not graded
quality
Not graded
maintenance
Enables AI assistants to perform semantic search, manage vectors, and interact with Pinecone vector databases through standardized MCP tools. Supports querying, upserting, deleting vectors and monitoring database statistics for knowledge base operations.
Updated a year ago (2025-09-10 03:08 UTC)
4 npm
-
Qdrant MCP Server
Vector Databases RAG Systems
Jimmy974
F
license
Not graded
quality
D
maintenance
Enables interaction with Qdrant vector database for storing, searching, and managing vectors with automatic text embedding.
Updated 2 years ago (2025-03-18 17:44 UTC)
1
-
MCP RAG Assistant
RAG Systems Databases File Systems
1jelly7
F
license
Not graded
quality
D
maintenance
Enables RAG (Retrieval-Augmented Generation) with tools for vector search, document access, and OpenAI integration, plus MySQL storage and file system operations via MCP.
Updated 4 months ago (2026-07-14 06:38 UTC)
-
rag-mcp-server
RAG Systems Search
q6066697
A
license
A
quality
C
maintenance
Exposes hybrid retrieval (dense embeddings + BM25 + RRF) and document operations (search, fetch, rerank) as MCP tools, using Qdrant and OpenAI embeddings for local or server mode.
Updated 2 months ago (2026-08-19 21:59 UTC)
3
MIT

Qdrant MCP

Table of Contents

Overview

Key Features

Requirements

Installation

PyPI

Docker

Claude Desktop bundle (.mcpb)

Quick Start

Connecting to Claude

Claude Desktop / Claude Code (local, stdio)

Remote (streamable-http)

Configuration Reference

Available Tools

Read-Only Mode

Architecture

Security

Development

Versioning & Changelog

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Claude Desktop bundle (`.mcpb`)

Claude Desktop / Claude Code (local, `stdio`)

Remote (`streamable-http`)