Ajout du dossier docs

docs/CODE_OF_CONDUCT.md

@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+email: [email protected].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.

docs/CONTRIBUTING.md

@@ -0,0 +1,49 @@
+# Contributing to Qdrant
+We love your input! We want to make contributing to this project as easy and transparent as possible, whether it's:
+
+- Reporting a bug
+- Discussing the current state of the code
+- Submitting a fix
+- Proposing new features
+
+## We Develop with GitHub
+We use github to host code, to track issues and feature requests, as well as accept pull requests.
+
+## We Use [GitHub Flow](https://guides.github.com/introduction/flow/index.html), So All Code Changes Happen Through Pull Requests
+Pull requests are the best way to propose changes to the codebase (we use [GitHub Flow](https://docs.github.com/en/get-started/quickstart/github-flow)). We actively welcome your pull requests:
+
+1. Fork the repo and create your branch from `dev`.
+2. If you've added code that should be tested, add tests.
+3. If you've changed APIs, update the documentation and API Schema definitions (see [development docs](https://github.com/qdrant/qdrant/blob/master/docs/DEVELOPMENT.md#api-changes))
+4. Ensure the test suite passes.
+5. Make sure your code lints (with cargo).
+6. Issue that pull request!
+
+## Any contributions you make will be under the Apache License 2.0
+In short, when you submit code changes, your submissions are understood to be under the same [Apache License 2.0](https://choosealicense.com/licenses/apache-2.0/) that covers the project. Feel free to contact the maintainers if that's a concern.
+
+## Report bugs using GitHub's [issues](https://github.com/qdrant/qdrant/issues)
+We use GitHub issues to track public bugs. Report a bug by [opening a new issue](https://github.com/qdrant/qdrant/issues/new/choose); it's that easy!
+
+## Write bug reports with detail, background, and sample code
+
+**Great Bug Reports** tend to have:
+
+- A quick summary and/or background
+- Steps to reproduce
+  - Be specific!
+  - Give sample code if you can.
+- What you expected would happen
+- What actually happens
+- Notes (possibly including why you think this might be happening, or stuff you tried that didn't work)
+
+## Use a Consistent Coding Style
+
+If you are modifying Rust code, make sure it has no warnings from Cargo and follow [Rust code style](https://doc.rust-lang.org/1.0.0/style/).
+The project uses [rustfmt](https://github.com/rust-lang/rustfmt) formatter. Please ensure to run it using the
+```cargo +nightly fmt --all``` command. The project also use [clippy](https://github.com/rust-lang/rust-clippy) lint collection,
+so please ensure running ``cargo clippy --workspace --all-features`` before submitting the PR.
+
+## License
+By contributing, you agree that your contributions will be licensed under its Apache License 2.0.
+

docs/DEVELOPMENT.md

@@ -0,0 +1,247 @@
+
+# Developer's guide to Qdrant
+
+
+## Build Qdrant
+
+### Docker 🐳
+
+Build your own from source
+
+```bash
+docker build . --tag=qdrant/qdrant
+```
+
+Or use latest pre-built image from [DockerHub](https://hub.docker.com/r/qdrant/qdrant)
+
+```bash
+docker pull qdrant/qdrant
+```
+
+To run the container, use the command:
+
+```bash
+docker run -p 6333:6333 qdrant/qdrant
+```
+
+And once you need a fine-grained setup, you can also define a storage path and custom configuration:
+
+```bash
+docker run -p 6333:6333 \
+    -v $(pwd)/path/to/data:/qdrant/storage \
+    -v $(pwd)/path/to/snapshots:/qdrant/snapshots \
+    -v $(pwd)/path/to/custom_config.yaml:/qdrant/config/production.yaml \
+    qdrant/qdrant
+```
+
+* `/qdrant/storage` - is the place where Qdrant persists all your data.
+Make sure to mount it as a volume, otherwise docker will drop it with the container.
+- `/qdrant/snapshots` - is the place where Qdrant stores [snapshots](https://qdrant.tech/documentation/concepts/snapshots/)
+* `/qdrant/config/production.yaml` - is the file with engine configuration. You can override any value from the [reference config](https://github.com/qdrant/qdrant/blob/master/config/config.yaml)
+
+Now Qdrant should be accessible at [localhost:6333](http://localhost:6333/).
+
+
+### Local development
+#### Linux/Debian/MacOS
+To run Qdrant on local development environment you need to install below:
+- Install Rust, follow: [install rust](https://www.rust-lang.org/tools/install)
+- Install `rustfmt` toolchain for Rust
+    ```shell
+    rustup component add rustfmt
+    ```
+- Install dependencies:
+    ```shell
+    sudo apt-get update -y
+    sudo apt-get upgrade -y
+    sudo apt-get install -y curl unzip gcc-multilib \
+        clang cmake jq \
+        g++-9-aarch64-linux-gnu \
+        gcc-9-aarch64-linux-gnu
+    ```
+- Install `protoc` from source
+    ```shell
+    PROTOC_VERSION=22.2
+    PKG_NAME=$(uname -s | awk '{print ($1 == "Darwin") ? "osx-universal_binary" : (($1 == "Linux") ? "linux-x86_64" : "")}')
+
+    # curl `proto` source file
+    curl -LO https://github.com/protocolbuffers/protobuf/releases//download/v$PROTOC_VERSION/protoc-$PROTOC_VERSION-$PKG_NAME.zip
+
+    unzip protoc-$PROTOC_VERSION-$PKG_NAME.zip -d $HOME/.local
+
+    export PATH="$PATH:$HOME/.local/bin"
+
+    # remove source file if not needed
+    rm protoc-$PROTOC_VERSION-$PKG_NAME.zip
+
+    # check installed `protoc` version
+    protoc --version
+    ```
+- Build and run the app
+    ```shell
+    cargo build --release --bin qdrant
+
+    ./target/release/qdrant
+    ```
+- Install Python dependencies for testing
+    ```shell
+    poetry -C tests install --sync
+    ```
+    Then you could use `poetry -C run pytest tests/openapi` and `poetry -C run pytest tests/consensus_tests` to run the tests.
+- Use the web UI
+
+    Web UI repo is [in a separate repo](https://github.com/qdrant/qdrant-web-ui), but there's a utility script to sync it to the `static` folder:
+    ```shell
+    ./tools/sync-web-ui.sh
+    ```
+
+### Nix/NixOS
+If you are using [Nix package manager](https://nixos.org/) (available for Linux and MacOS), you can run `nix-shell` in the project root to get a shell with all dependencies installed.
+It includes dependencies to build Rust code as well as to run Python tests and various tools in the `./tools` directory.
+
+## Profiling
+
+There are several benchmarks implemented in Qdrant. Benchmarks are not included in CI/CD and might take some time to execute.
+So the expected approach to benchmarking is to run only ones which might be affected by your changes.
+
+To run benchmark, use the following command inside a related sub-crate:
+
+```bash
+cargo bench --bench name_of_benchmark
+```
+
+In this case you will see the execution timings and, if you launched this bench earlier, the difference in execution time.
+
+Example output:
+
+```
+scoring-vector/basic-score-point
+                        time:   [111.81 us 112.07 us 112.31 us]
+                        change: [+19.567% +20.454% +21.404%] (p = 0.00 < 0.05)
+                        Performance has regressed.
+Found 9 outliers among 100 measurements (9.00%)
+  3 (3.00%) low severe
+  3 (3.00%) low mild
+  2 (2.00%) high mild
+  1 (1.00%) high severe
+scoring-vector/basic-score-point-10x
+                        time:   [111.86 us 112.44 us 113.04 us]
+                        change: [-1.6120% -0.5554% +0.5103%] (p = 0.32 > 0.05)
+                        No change in performance detected.
+Found 1 outliers among 100 measurements (1.00%)
+  1 (1.00%) high mild
+```
+
+
+### FlameGraph and call-graph visualisation
+To run benchmarks with profiler to generate FlameGraph - use the following command:
+
+```bash
+cargo bench --bench name_of_benchmark -- --profile-time=60
+```
+
+This command will run each benchmark iterator for `60` seconds and generate FlameGraph svg along with profiling records files.
+These records could later be used to generate visualisation of the call-graph.
+
+![FlameGraph example](./imgs/flamegraph-profile.png)
+
+Use [pprof](https://github.com/google/pprof) and the following command to generate `svg` with a call graph:
+
+```bash
+~/go/bin/pprof -output=profile.svg -svg ${qdrant_root}/target/criterion/${benchmark_name}/${function_name}/profile/profile.pb
+```
+
+![call-graph example](./imgs/call-graph-profile.png)
+
+### Real-time profiling
+
+Qdrant have basic [`tracing`] support with [`Tracy`] profiler and [`tokio-console`] integrations
+that can be enabled with optional features.
+
+- [`tracing`] is an _optional_ dependency that can be enabled with `tracing` feature
+- `tracy` feature enables [`Tracy`] profiler integration
+- `console` feature enables [`tokio-console`] integration
+  - note, that you'll also have to [pass `--cfg tokio_unstable` arguments to `rustc`][tokio-tracing] to enable this feature
+  - by default [`tokio-console`] binds to `127.0.0.1:6669`
+  - if you want to connect [`tokio-console`] to Qdrant instance running inside a Docker container
+    or on remote server, you can define `TOKIO_CONSOLE_BIND` when running Qdrant to override it
+    (e.g., `TOKIO_CONSOLE_BIND=0.0.0.0:6669` to listen on all interfaces)
+- `tokio-tracing` feature explicitly enables [`Tokio` crate tracing][tokio-tracing]
+  - note, that you'll also have to [pass `--cfg tokio_unstable` arguments to `rustc`][tokio-tracing] to enable this feature
+  - this is required (and enabled automatically) by the `console` feature
+  - but you can enable it explicitly with the `tracy` feature, to see Tokio traces in [`Tracy`] profiler
+
+Qdrant code is **not** instrumented by default, so you'll have to manually add `#[tracing::instrument]` attributes
+on functions and methods that you want to profile.
+
+Qdrant uses [`tracing-log`] as the [`log`] backend, so `log` and `log-always` features of the [`tracing`] crate
+[should _not_ be enabled][tracing-log-warning]!
+
+```rust
+// `tracing` crate is an *optional* dependency in `lib/*` crates, so if you want the code to compile
+// when `tracing` feature is disabled, you have to use `#[cfg_attr(...)]`...
+//
+// See https://doc.rust-lang.org/reference/conditional-compilation.html#the-cfg_attr-attribute
+#[cfg_attr(feature = "tracing", tracing::instrument)]
+fn my_function(some_parameter: String) {
+    // ...
+}
+
+// ...or if you just want to do some quick-and-dirty profiling, you can use `#[tracing::instrument]`
+// directly, just don't forget to add `--features tracing` when running `cargo` (or add `tracing`
+// to default features in `Cargo.toml`)
+#[tracing::instrument]
+fn some_other_function() {
+    // ...
+}
+```
+
+[`tracing`]: https://docs.rs/tracing/latest/tracing/
+[`Tracy`]: https://github.com/wolfpld/tracy
+[`tokio-console`]: https://docs.rs/tokio-console/latest/tokio_console/
+[tokio-tracing]: https://docs.rs/tokio/latest/tokio/#unstable-features
+[`tracing-log`]: https://docs.rs/tracing-log/latest/tracing_log/
+[`log`]: https://docs.rs/log/latest/log/
+[tracing-log-warning]: https://docs.rs/tracing-log/latest/tracing_log/#caution-mixing-both-conversions
+
+## API changes
+
+### REST
+
+Qdrant uses the [openapi](https://spec.openapis.org/oas/latest.html) specification to document its API.
+
+This means changes to the API must be followed by changes to the specification.
+This is enforced by CI.
+
+Here is a quick step-by-step guide:
+
+1. code endpoints and model in Rust
+2. change specs in `/openapi/*ytt.yaml`
+3. add new schema definitions to `src/schema_generator.rs`
+4. run `./tools/generate_openapi_models.sh` to generate specs
+5. update integration tests `tests/openapi` and run them with `pytest tests/openapi` (use poetry or nix to get `pytest`)
+6. expose file by starting an HTTP server, for instance `python -m http.server`, in `/docs/redoc`
+7. validate specs by browsing redoc on `http://localhost:8000/?v=master`
+8. validate `openapi-merged.yaml` using [swagger editor](https://editor.swagger.io/)
+
+### gRPC
+
+Qdrant uses [tonic](https://github.com/hyperium/tonic) to serve gRPC traffic.
+
+Our protocol buffers are defined in `lib/api/src/grpc/proto/*.proto`
+
+1. define request and response types using protocol buffers (use [oneOf](https://developers.google.com/protocol-buffers/docs/proto3#oneof) for enums payloads)
+2. specify RPC methods inside the service definition using protocol buffers
+3. `cargo build` will generate the struct definitions and a service trait
+4. implement the service trait in Rust
+5. start server `cargo run --bin qdrant`
+6. run integration test `./tests/basic_grpc_test.sh`
+7. generate docs `./tools/generate_grpc_docs.sh`
+
+Here is a good [tonic tutorial](https://github.com/hyperium/tonic/blob/master/examples/routeguide-tutorial.md#defining-the-service) for reference.
+
+### System integration
+
+On top of the API definitions, Qdrant has a few system integrations that need to be considered when making changes:
+1. add new endpoints to the metrics allow lists in `src/common/metrics.rs`
+2. test the JWT integration in `tests/auth_tests`

docs/QUICK_START.md

@@ -0,0 +1,209 @@
+# Quick Start
+
+This example covers the most basic use-case - collection creation and basic vector search.
+For additional information please refer to the [API documentation](https://api.qdrant.tech/).
+
+## Docker 🐳
+
+Use latest pre-built image from [DockerHub](https://hub.docker.com/r/qdrant/qdrant)
+
+```bash
+docker pull qdrant/qdrant
+```
+
+Run it with default configuration:
+
+```bash
+docker run -p 6333:6333 qdrant/qdrant
+```
+
+Build your own from source
+
+```bash
+docker build . --tag=qdrant/qdrant
+```
+
+And once you need a fine-grained setup, you can also define a storage path and custom configuration:
+
+```bash
+docker run -p 6333:6333 \
+    -v $(pwd)/path/to/data:/qdrant/storage \
+    -v $(pwd)/path/to/snapshots:/qdrant/snapshots \
+    -v $(pwd)/path/to/custom_config.yaml:/qdrant/config/production.yaml \
+    qdrant/qdrant
+```
+
+- `/qdrant/storage` - is the place where Qdrant persists all your data.
+  Make sure to mount it as a volume, otherwise docker will drop it with the container.
+- `/qdrant/snapshots` - is the place where Qdrant stores [snapshots](https://qdrant.tech/documentation/concepts/snapshots/)
+- `/qdrant/config/production.yaml` - is the file with engine configuration. You can override any value from the [reference config](https://github.com/qdrant/qdrant/blob/master/config/config.yaml). In a real production environment, you should enable authentication by setting `service.apiKey`.
+- For production environments, consider also setting [`--read-only`](https://docs.docker.com/reference/cli/docker/container/run/#read-only) and `--user=1000:2000` to further secure your Qdrant instance. Or use [our Helm chart](https://github.com/qdrant/qdrant-helm) or [Qdrant Cloud](https://qdrant.tech/documentation/cloud/) which sets these by default.
+
+Now Qdrant should be accessible at [localhost:6333](http://localhost:6333/).
+
+## Create collection
+
+First - let's create a collection with dot-production metric.
+
+```bash
+curl -X PUT 'http://localhost:6333/collections/test_collection' \
+    -H 'Content-Type: application/json' \
+    --data-raw '{
+        "vectors": {
+          "size": 4,
+          "distance": "Dot"
+        }
+    }'
+```
+
+Expected response:
+
+```json
+{
+  "result": true,
+  "status": "ok",
+  "time": 0.031095451
+}
+```
+
+We can ensure that collection was created:
+
+```bash
+curl 'http://localhost:6333/collections/test_collection'
+```
+
+Expected response:
+
+```json
+{
+  "result": {
+    "status": "green",
+    "vectors_count": 0,
+    "segments_count": 5,
+    "disk_data_size": 0,
+    "ram_data_size": 0,
+    "config": {
+      "params": {
+        "vectors": {
+          "size": 4,
+          "distance": "Dot"
+        }
+      },
+      "hnsw_config": {
+        "m": 16,
+        "ef_construct": 100,
+        "full_scan_threshold": 10000
+      },
+      "optimizer_config": {
+        "deleted_threshold": 0.2,
+        "vacuum_min_vector_number": 1000,
+        "default_segment_number": 2,
+        "max_segment_size": null,
+        "memmap_threshold": null,
+        "indexing_threshold": 20000,
+        "flush_interval_sec": 5,
+        "max_optimization_threads": null
+      },
+      "wal_config": {
+        "wal_capacity_mb": 32,
+        "wal_segments_ahead": 0
+      }
+    }
+  },
+  "status": "ok",
+  "time": 2.1199e-5
+}
+```
+
+## Add points
+
+Let's now add vectors with some payload:
+
+```bash
+curl -L -X PUT 'http://localhost:6333/collections/test_collection/points?wait=true' \
+    -H 'Content-Type: application/json' \
+    --data-raw '{
+        "points": [
+          {"id": 1, "vector": [0.05, 0.61, 0.76, 0.74], "payload": {"city": "Berlin"}},
+          {"id": 2, "vector": [0.19, 0.81, 0.75, 0.11], "payload": {"city": ["Berlin", "London"] }},
+          {"id": 3, "vector": [0.36, 0.55, 0.47, 0.94], "payload": {"city": ["Berlin", "Moscow"] }},
+          {"id": 4, "vector": [0.18, 0.01, 0.85, 0.80], "payload": {"city": ["London", "Moscow"] }},
+          {"id": 5, "vector": [0.24, 0.18, 0.22, 0.44], "payload": {"count": [0] }},
+          {"id": 6, "vector": [0.35, 0.08, 0.11, 0.44]}
+        ]
+    }'
+```
+
+Expected response:
+
+```json
+{
+  "result": {
+    "operation_id": 0,
+    "status": "completed"
+  },
+  "status": "ok",
+  "time": 0.000206061
+}
+```
+
+## Search with filtering
+
+Let's start with a basic request:
+
+```bash
+curl -L -X POST 'http://localhost:6333/collections/test_collection/points/search' \
+    -H 'Content-Type: application/json' \
+    --data-raw '{
+        "vector": [0.2,0.1,0.9,0.7],
+        "top": 3
+    }'
+```
+
+Expected response:
+
+```json
+{
+  "result": [
+    { "id": 4, "score": 1.362, "payload": null, "version": 0 },
+    { "id": 1, "score": 1.273, "payload": null, "version": 0 },
+    { "id": 3, "score": 1.208, "payload": null, "version": 0 }
+  ],
+  "status": "ok",
+  "time": 0.000055785
+}
+```
+
+But result is different if we add a filter:
+
+```bash
+curl -L -X POST 'http://localhost:6333/collections/test_collection/points/search' \
+    -H 'Content-Type: application/json' \
+    --data-raw '{
+      "filter": {
+          "should": [
+              {
+                  "key": "city",
+                  "match": {
+                      "value": "London"
+                  }
+              }
+          ]
+      },
+      "vector": [0.2, 0.1, 0.9, 0.7],
+      "top": 3
+  }'
+```
+
+Expected response:
+
+```json
+{
+  "result": [
+    { "id": 4, "score": 1.362 },
+    { "id": 2, "score": 0.871 }
+  ],
+  "status": "ok",
+  "time": 0.000093972
+}
+```

docs/redoc/.gitignore

@@ -0,0 +1 @@
+/openapi.json

docs/redoc/default_version.js

@@ -0,0 +1 @@
+const defaultApiVersion = 'v1.12.x';

docs/redoc/index.html

@@ -0,0 +1,99 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>ReDoc</title>
+    <!-- needed for adaptive design -->
+    <meta charset="utf-8"/>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css"
+          integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
+
+    <!--
+    ReDoc doesn't change outer page styles
+    -->
+    <style>
+        body {
+            margin: 0;
+            padding: 0;
+        }
+    </style>
+    <script src="./default_version.js"></script>
+
+    <script>
+        const url_string = window.location.href;
+        const url = new URL(url_string);
+        const version = url.searchParams.get("v") || defaultApiVersion;
+    </script>
+</head>
+<body>
+<nav class="navbar navbar-light justify-content-between" style="background-color: rgb(250, 250, 250);">
+    <a class="navbar-brand" href="#">
+        <img src="../logo.svg" height="30">
+    </a>
+
+    <div class="btn-group">
+        <button type="button" class="btn btn-secondary dropdown-toggle" data-toggle="dropdown" aria-haspopup="true"
+                aria-expanded="false">
+            Version
+        </button>
+        <div class="dropdown-menu dropdown-menu-right">
+            <a href="?v=master" class="dropdown-item" type="button">master</a>
+            <a href="?v=v1.12.x" class="dropdown-item" type="button">v1.12.x</a>
+            <a href="?v=v1.11.x" class="dropdown-item" type="button">v1.11.x</a>
+            <a href="?v=v1.10.x" class="dropdown-item" type="button">v1.10.x</a>
+            <a href="?v=v1.9.x" class="dropdown-item" type="button">v1.9.x</a>
+            <a href="?v=v1.8.x" class="dropdown-item" type="button">v1.8.x</a>
+            <a href="?v=v1.7.x" class="dropdown-item" type="button">v1.7.x</a>
+            <a href="?v=v1.6.x" class="dropdown-item" type="button">v1.6.x</a>
+            <a href="?v=v1.5.x" class="dropdown-item" type="button">v1.5.x</a>
+            <a href="?v=v1.4.x" class="dropdown-item" type="button">v1.4.x</a>
+            <a href="?v=v1.3.x" class="dropdown-item" type="button">v1.3.x</a>
+            <a href="?v=v1.2.x" class="dropdown-item" type="button">v1.2.x</a>
+            <a href="?v=v1.1.3" class="dropdown-item" type="button">v1.1.3</a>
+            <a href="?v=v1.1.2" class="dropdown-item" type="button">v1.1.2</a>
+            <a href="?v=v1.1.1" class="dropdown-item" type="button">v1.1.1</a>
+            <a href="?v=v1.1.0" class="dropdown-item" type="button">v1.1.0</a>
+            <a href="?v=v1.0.3" class="dropdown-item" type="button">v1.0.3</a>
+            <a href="?v=v1.0.2" class="dropdown-item" type="button">v1.0.2</a>
+            <a href="?v=v1.0.1" class="dropdown-item" type="button">v1.0.1</a>
+            <a href="?v=v0.11.7" class="dropdown-item" type="button">v0.11.7</a>
+        </div>
+    </div>
+
+</nav>
+
+<redoc id="redoc-container" spec-url='./openapi.json' theme='
+{
+    "colors": {
+        "primary": {
+            "main": "#bc1439"
+        }
+    },
+    "rightPanel": {
+        "backgroundColor": "#182b3a"
+    },
+    "codeBlock": {
+        "backgroundColor": "#182b3a"
+    }
+}
+'></redoc>
+
+<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js"
+        integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo"
+        crossorigin="anonymous"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js"
+        integrity="sha384-ZMP7rVo3mIykV+2+9J3UJ46jBk0WLaUAdn689aCwoqbBJiSnjAK/l8WvCWPIPm49"
+        crossorigin="anonymous"></script>
+<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js"
+        integrity="sha384-ChfqqxuZUCnJSK3+MXmPNIyE6ZbWh2IMqE241rYiqJxyMiZ6OW/JmZQ5stwEULTy"
+        crossorigin="anonymous"></script>
+
+<script>
+    $('#redoc-container').attr("spec-url", "./" + version + "/openapi.json");
+</script>
+
+<script src="https://cdn.jsdelivr.net/npm/redoc@next/bundles/redoc.standalone.js"></script>
+
+</body>
+</html>

docs/redoc/v0.4.2/openapi.json

@@ -0,0 +1,2357 @@
+{
+  "components": {
+    "schemas": {
+      "AliasOperations": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Create alternative name for a collection. Collection will be available under both names for search, retrieve,",
+            "properties": {
+              "create_alias": {
+                "properties": {
+                  "alias_name": {
+                    "type": "string"
+                  },
+                  "collection_name": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "alias_name",
+                  "collection_name"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "create_alias"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Delete alias if exists",
+            "properties": {
+              "delete_alias": {
+                "properties": {
+                  "alias_name": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "alias_name"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "delete_alias"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Change alias to a new one",
+            "properties": {
+              "rename_alias": {
+                "properties": {
+                  "new_alias_name": {
+                    "type": "string"
+                  },
+                  "old_alias_name": {
+                    "type": "string"
+                  }
+                },
+                "required": [
+                  "new_alias_name",
+                  "old_alias_name"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "rename_alias"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "CollectionConfig": {
+        "properties": {
+          "hnsw_config": {
+            "$ref": "#/components/schemas/HnswConfig"
+          },
+          "optimizer_config": {
+            "$ref": "#/components/schemas/OptimizersConfig"
+          },
+          "params": {
+            "$ref": "#/components/schemas/CollectionParams"
+          },
+          "wal_config": {
+            "$ref": "#/components/schemas/WalConfig"
+          }
+        },
+        "required": [
+          "hnsw_config",
+          "optimizer_config",
+          "params",
+          "wal_config"
+        ],
+        "type": "object"
+      },
+      "CollectionDescription": {
+        "properties": {
+          "name": {
+            "type": "string"
+          }
+        },
+        "required": [
+          "name"
+        ],
+        "type": "object"
+      },
+      "CollectionInfo": {
+        "description": "Current statistics and configuration of the collection.",
+        "properties": {
+          "config": {
+            "$ref": "#/components/schemas/CollectionConfig"
+          },
+          "disk_data_size": {
+            "description": "Disk space, used by collection",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "payload_schema": {
+            "additionalProperties": {
+              "$ref": "#/components/schemas/PayloadSchemaInfo"
+            },
+            "description": "Types of stored payload",
+            "type": "object"
+          },
+          "ram_data_size": {
+            "description": "RAM used by collection",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "segments_count": {
+            "description": "Number of segments in collection",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "status": {
+            "$ref": "#/components/schemas/CollectionStatus"
+          },
+          "vectors_count": {
+            "description": "Number of vectors in collection",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "config",
+          "disk_data_size",
+          "payload_schema",
+          "ram_data_size",
+          "segments_count",
+          "status",
+          "vectors_count"
+        ],
+        "type": "object"
+      },
+      "CollectionParams": {
+        "properties": {
+          "distance": {
+            "$ref": "#/components/schemas/Distance"
+          },
+          "vector_size": {
+            "description": "Size of a vectors used",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "distance",
+          "vector_size"
+        ],
+        "type": "object"
+      },
+      "CollectionStatus": {
+        "enum": [
+          "green",
+          "yellow",
+          "red"
+        ],
+        "type": "string"
+      },
+      "CollectionUpdateOperations": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/PointOperations"
+          },
+          {
+            "$ref": "#/components/schemas/PayloadOps"
+          },
+          {
+            "$ref": "#/components/schemas/FieldIndexOperations"
+          }
+        ]
+      },
+      "CollectionsResponse": {
+        "properties": {
+          "collections": {
+            "items": {
+              "$ref": "#/components/schemas/CollectionDescription"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "collections"
+        ],
+        "type": "object"
+      },
+      "Condition": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/FieldCondition"
+          },
+          {
+            "$ref": "#/components/schemas/HasIdCondition"
+          },
+          {
+            "$ref": "#/components/schemas/Filter"
+          }
+        ]
+      },
+      "Distance": {
+        "description": "Type of internal tags, build from payload Distance function types used to compare vectors",
+        "enum": [
+          "Cosine",
+          "Euclid",
+          "Dot"
+        ],
+        "type": "string"
+      },
+      "ErrorResponse": {
+        "properties": {
+          "result": {
+            "nullable": true,
+            "type": "object"
+          },
+          "status": {
+            "properties": {
+              "error": {
+                "description": "Description of the occurred error.",
+                "type": "string"
+              }
+            },
+            "type": "object"
+          },
+          "time": {
+            "description": "Time spent to process this request",
+            "format": "float",
+            "type": "number"
+          }
+        },
+        "type": "object"
+      },
+      "FieldCondition": {
+        "properties": {
+          "geo_bounding_box": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/GeoBoundingBox"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Check if points geo location lies in a given area"
+          },
+          "geo_radius": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/GeoRadius"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Check if geo point is within a given radius"
+          },
+          "key": {
+            "type": "string"
+          },
+          "match": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Match"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Check if point has field with a given value"
+          },
+          "range": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Range"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Check if points value lies in a given range"
+          }
+        },
+        "required": [
+          "key"
+        ],
+        "type": "object"
+      },
+      "FieldIndexOperations": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Create index for payload field",
+            "properties": {
+              "create_index": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "create_index"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Delete index for the field",
+            "properties": {
+              "delete_index": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "delete_index"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "Filter": {
+        "additionalProperties": false,
+        "properties": {
+          "must": {
+            "description": "All conditions must match",
+            "items": {
+              "$ref": "#/components/schemas/Condition"
+            },
+            "nullable": true,
+            "type": "array"
+          },
+          "must_not": {
+            "description": "All conditions must NOT match",
+            "items": {
+              "$ref": "#/components/schemas/Condition"
+            },
+            "nullable": true,
+            "type": "array"
+          },
+          "should": {
+            "description": "At least one of thous conditions should match",
+            "items": {
+              "$ref": "#/components/schemas/Condition"
+            },
+            "nullable": true,
+            "type": "array"
+          }
+        },
+        "type": "object"
+      },
+      "GeoBoundingBox": {
+        "properties": {
+          "bottom_right": {
+            "$ref": "#/components/schemas/GeoPoint"
+          },
+          "top_left": {
+            "$ref": "#/components/schemas/GeoPoint"
+          }
+        },
+        "required": [
+          "bottom_right",
+          "top_left"
+        ],
+        "type": "object"
+      },
+      "GeoPoint": {
+        "properties": {
+          "lat": {
+            "format": "double",
+            "type": "number"
+          },
+          "lon": {
+            "format": "double",
+            "type": "number"
+          }
+        },
+        "required": [
+          "lat",
+          "lon"
+        ],
+        "type": "object"
+      },
+      "GeoRadius": {
+        "properties": {
+          "center": {
+            "$ref": "#/components/schemas/GeoPoint"
+          },
+          "radius": {
+            "description": "Radius of the area in meters",
+            "format": "double",
+            "type": "number"
+          }
+        },
+        "required": [
+          "center",
+          "radius"
+        ],
+        "type": "object"
+      },
+      "HasIdCondition": {
+        "properties": {
+          "has_id": {
+            "items": {
+              "format": "uint64",
+              "minimum": 0,
+              "type": "integer"
+            },
+            "type": "array",
+            "uniqueItems": true
+          }
+        },
+        "required": [
+          "has_id"
+        ],
+        "type": "object"
+      },
+      "HnswConfig": {
+        "properties": {
+          "ef_construct": {
+            "description": "Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build index.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "full_scan_threshold": {
+            "description": "Minimal amount of points for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "m": {
+            "description": "Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "ef_construct",
+          "full_scan_threshold",
+          "m"
+        ],
+        "type": "object"
+      },
+      "HnswConfigDiff": {
+        "properties": {
+          "ef_construct": {
+            "description": "Number of neighbours to consider during the index building. Larger the value - more accurate the search, more time required to build index.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "full_scan_threshold": {
+            "description": "Minimal amount of points for additional payload-based indexing. If payload chunk is smaller than `full_scan_threshold` additional indexing won't be used - in this case full-scan search should be preferred by query planner and additional indexing is not required.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "m": {
+            "description": "Number of edges per node in the index graph. Larger the value - more accurate the search, more space required.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "Match": {
+        "properties": {
+          "integer": {
+            "description": "Integer value to match",
+            "format": "int64",
+            "nullable": true,
+            "type": "integer"
+          },
+          "keyword": {
+            "description": "Keyword value to match",
+            "nullable": true,
+            "type": "string"
+          }
+        },
+        "type": "object"
+      },
+      "OptimizersConfig": {
+        "properties": {
+          "deleted_threshold": {
+            "description": "The minimal fraction of deleted vectors in a segment, required to perform segment optimization",
+            "format": "double",
+            "type": "number"
+          },
+          "flush_interval_sec": {
+            "description": "Minimum interval between forced flushes.",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "indexing_threshold": {
+            "description": "Maximum number of vectors allowed for plain index. Default value based on https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "max_segment_number": {
+            "description": "If the number of segments exceeds this value, the optimizer will merge the smallest segments.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "memmap_threshold": {
+            "description": "Maximum number of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmaped file.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "payload_indexing_threshold": {
+            "description": "Starting from this amount of vectors per-segment the engine will start building index for payload.",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "vacuum_min_vector_number": {
+            "description": "The minimal number of vectors in a segment, required to perform segment optimization",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "deleted_threshold",
+          "flush_interval_sec",
+          "indexing_threshold",
+          "max_segment_number",
+          "memmap_threshold",
+          "payload_indexing_threshold",
+          "vacuum_min_vector_number"
+        ],
+        "type": "object"
+      },
+      "OptimizersConfigDiff": {
+        "properties": {
+          "deleted_threshold": {
+            "description": "The minimal fraction of deleted vectors in a segment, required to perform segment optimization",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          },
+          "flush_interval_sec": {
+            "description": "Minimum interval between forced flushes.",
+            "format": "uint64",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "indexing_threshold": {
+            "description": "Maximum number of vectors allowed for plain index. Default value based on https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "max_segment_number": {
+            "description": "If the number of segments exceeds this value, the optimizer will merge the smallest segments.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "memmap_threshold": {
+            "description": "Maximum number of vectors to store in-memory per segment. Segments larger than this threshold will be stored as read-only memmaped file.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "payload_indexing_threshold": {
+            "description": "Starting from this amount of vectors per-segment the engine will start building index for payload.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "vacuum_min_vector_number": {
+            "description": "The minimal number of vectors in a segment, required to perform segment optimization",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "PayloadInterface": {
+        "anyOf": [
+          {
+            "$ref": "#/components/schemas/PayloadVariant_for_String"
+          },
+          {
+            "$ref": "#/components/schemas/PayloadVariant_for_int64"
+          },
+          {
+            "$ref": "#/components/schemas/PayloadVariant_for_double"
+          },
+          {
+            "$ref": "#/components/schemas/PayloadInterfaceStrict"
+          }
+        ]
+      },
+      "PayloadInterfaceStrict": {
+        "anyOf": [
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "keyword"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "$ref": "#/components/schemas/PayloadVariant_for_String"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "integer"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "$ref": "#/components/schemas/PayloadVariant_for_int64"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "float"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "$ref": "#/components/schemas/PayloadVariant_for_double"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "geo"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "$ref": "#/components/schemas/PayloadVariant_for_GeoPoint"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "PayloadOps": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Set payload value, overrides if it is already exists",
+            "properties": {
+              "set_payload": {
+                "properties": {
+                  "payload": {
+                    "additionalProperties": {
+                      "$ref": "#/components/schemas/PayloadInterface"
+                    },
+                    "type": "object"
+                  },
+                  "points": {
+                    "description": "Assigns payload to each point in this list",
+                    "items": {
+                      "format": "uint64",
+                      "minimum": 0,
+                      "type": "integer"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "payload",
+                  "points"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "set_payload"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Deletes specified payload values if they are assigned",
+            "properties": {
+              "delete_payload": {
+                "properties": {
+                  "keys": {
+                    "items": {
+                      "type": "string"
+                    },
+                    "type": "array"
+                  },
+                  "points": {
+                    "description": "Deletes values from each point in this list",
+                    "items": {
+                      "format": "uint64",
+                      "minimum": 0,
+                      "type": "integer"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "keys",
+                  "points"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "delete_payload"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Drops all Payload values associated with given points.",
+            "properties": {
+              "clear_payload": {
+                "properties": {
+                  "points": {
+                    "items": {
+                      "format": "uint64",
+                      "minimum": 0,
+                      "type": "integer"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "points"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "clear_payload"
+            ],
+            "type": "object"
+          }
+        ],
+        "description": "Define operations description for point payloads manipulation"
+      },
+      "PayloadSchemaInfo": {
+        "properties": {
+          "data_type": {
+            "$ref": "#/components/schemas/PayloadSchemaType"
+          },
+          "indexed": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "data_type",
+          "indexed"
+        ],
+        "type": "object"
+      },
+      "PayloadSchemaType": {
+        "anyOf": [
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "keyword"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "integer"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "float"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "geo"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "PayloadSelector": {
+        "additionalProperties": false,
+        "properties": {
+          "exclude": {
+            "description": "Post-exclude return payload key type",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          "include": {
+            "description": "Include return payload key type",
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "exclude",
+          "include"
+        ],
+        "type": "object"
+      },
+      "PayloadType": {
+        "anyOf": [
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "keyword"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "items": {
+                  "type": "string"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "integer"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "items": {
+                  "format": "int64",
+                  "type": "integer"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "float"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "items": {
+                  "format": "double",
+                  "type": "number"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          },
+          {
+            "properties": {
+              "type": {
+                "enum": [
+                  "geo"
+                ],
+                "type": "string"
+              },
+              "value": {
+                "items": {
+                  "$ref": "#/components/schemas/GeoPoint"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "type",
+              "value"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "PayloadVariant_for_GeoPoint": {
+        "anyOf": [
+          {
+            "items": {
+              "$ref": "#/components/schemas/GeoPoint"
+            },
+            "type": "array"
+          },
+          {
+            "$ref": "#/components/schemas/GeoPoint"
+          }
+        ]
+      },
+      "PayloadVariant_for_String": {
+        "anyOf": [
+          {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          {
+            "type": "string"
+          }
+        ]
+      },
+      "PayloadVariant_for_double": {
+        "anyOf": [
+          {
+            "items": {
+              "format": "double",
+              "type": "number"
+            },
+            "type": "array"
+          },
+          {
+            "format": "double",
+            "type": "number"
+          }
+        ]
+      },
+      "PayloadVariant_for_int64": {
+        "anyOf": [
+          {
+            "items": {
+              "format": "int64",
+              "type": "integer"
+            },
+            "type": "array"
+          },
+          {
+            "format": "int64",
+            "type": "integer"
+          }
+        ]
+      },
+      "PointInsertOperations": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Inset points from a batch.",
+            "properties": {
+              "batch": {
+                "properties": {
+                  "ids": {
+                    "items": {
+                      "format": "uint64",
+                      "minimum": 0,
+                      "type": "integer"
+                    },
+                    "type": "array"
+                  },
+                  "payloads": {
+                    "items": {
+                      "additionalProperties": {
+                        "$ref": "#/components/schemas/PayloadInterface"
+                      },
+                      "nullable": true,
+                      "type": "object"
+                    },
+                    "nullable": true,
+                    "type": "array"
+                  },
+                  "vectors": {
+                    "items": {
+                      "items": {
+                        "format": "float",
+                        "type": "number"
+                      },
+                      "type": "array"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "ids",
+                  "vectors"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "batch"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Insert points from a list",
+            "properties": {
+              "points": {
+                "items": {
+                  "$ref": "#/components/schemas/PointStruct"
+                },
+                "type": "array"
+              }
+            },
+            "required": [
+              "points"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "PointOperations": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Insert or update points",
+            "properties": {
+              "upsert_points": {
+                "$ref": "#/components/schemas/PointInsertOperations"
+              }
+            },
+            "required": [
+              "upsert_points"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Delete point if exists",
+            "properties": {
+              "delete_points": {
+                "properties": {
+                  "ids": {
+                    "items": {
+                      "format": "uint64",
+                      "minimum": 0,
+                      "type": "integer"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "ids"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "delete_points"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "PointRequest": {
+        "properties": {
+          "ids": {
+            "items": {
+              "format": "uint64",
+              "minimum": 0,
+              "type": "integer"
+            },
+            "type": "array"
+          },
+          "with_payload": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/WithPayloadInterface"
+              },
+              {
+                "nullable": true
+              }
+            ]
+          }
+        },
+        "required": [
+          "ids"
+        ],
+        "type": "object"
+      },
+      "PointStruct": {
+        "properties": {
+          "id": {
+            "description": "Point id",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "payload": {
+            "additionalProperties": {
+              "$ref": "#/components/schemas/PayloadInterface"
+            },
+            "description": "Payload values (optional)",
+            "nullable": true,
+            "type": "object"
+          },
+          "vector": {
+            "description": "Vector",
+            "items": {
+              "format": "float",
+              "type": "number"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "id",
+          "vector"
+        ],
+        "type": "object"
+      },
+      "Range": {
+        "properties": {
+          "gt": {
+            "description": "point.key > range.gt",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          },
+          "gte": {
+            "description": "point.key >= range.gte",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          },
+          "lt": {
+            "description": "point.key < range.lt",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          },
+          "lte": {
+            "description": "point.key <= range.lte",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          }
+        },
+        "type": "object"
+      },
+      "RecommendRequest": {
+        "description": "Search request",
+        "properties": {
+          "filter": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Filter"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Look only for points which satisfies this conditions"
+          },
+          "negative": {
+            "description": "Try to avoid vectors like this",
+            "items": {
+              "format": "uint64",
+              "minimum": 0,
+              "type": "integer"
+            },
+            "type": "array"
+          },
+          "params": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/SearchParams"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Additional search params"
+          },
+          "positive": {
+            "description": "Look for vectors closest to those",
+            "items": {
+              "format": "uint64",
+              "minimum": 0,
+              "type": "integer"
+            },
+            "type": "array"
+          },
+          "top": {
+            "description": "Max number of result to return",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "negative",
+          "positive",
+          "top"
+        ],
+        "type": "object"
+      },
+      "Record": {
+        "description": "Point data",
+        "properties": {
+          "id": {
+            "description": "Id of the point",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "payload": {
+            "additionalProperties": {
+              "$ref": "#/components/schemas/PayloadType"
+            },
+            "description": "Payload - values assigned to the point",
+            "nullable": true,
+            "type": "object"
+          },
+          "vector": {
+            "description": "Vector of the point",
+            "items": {
+              "format": "float",
+              "type": "number"
+            },
+            "nullable": true,
+            "type": "array"
+          }
+        },
+        "required": [
+          "id"
+        ],
+        "type": "object"
+      },
+      "ScoredPoint": {
+        "properties": {
+          "id": {
+            "description": "Point id",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "payload": {
+            "additionalProperties": {
+              "$ref": "#/components/schemas/PayloadType"
+            },
+            "description": "Payload storage",
+            "nullable": true,
+            "type": "object"
+          },
+          "score": {
+            "description": "Points vector distance to the query vector",
+            "format": "float",
+            "type": "number"
+          },
+          "version": {
+            "description": "Point version",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "id",
+          "score",
+          "version"
+        ],
+        "type": "object"
+      },
+      "ScrollRequest": {
+        "description": "Scroll request - paginate over all points which matches given condition",
+        "properties": {
+          "filter": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Filter"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Look only for points which satisfies this conditions. If not provided - all points."
+          },
+          "limit": {
+            "description": "Page size. Default: 10",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "offset": {
+            "description": "Start ID to read points from. Default: 0",
+            "format": "uint64",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "with_payload": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/WithPayloadInterface"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Return point payload with the result. Default: True"
+          },
+          "with_vector": {
+            "description": "Return point vector with the result. Default: false",
+            "nullable": true,
+            "type": "boolean"
+          }
+        },
+        "type": "object"
+      },
+      "ScrollResult": {
+        "description": "Result of the points read request. Contains",
+        "properties": {
+          "next_page_offset": {
+            "description": "Offset which should be used to retrieve a next page result",
+            "format": "uint64",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "points": {
+            "description": "List of retrieved points",
+            "items": {
+              "$ref": "#/components/schemas/Record"
+            },
+            "type": "array"
+          }
+        },
+        "required": [
+          "points"
+        ],
+        "type": "object"
+      },
+      "SearchParams": {
+        "description": "Additional parameters of the search",
+        "properties": {
+          "hnsw_ef": {
+            "description": "Params relevant to HNSW index /// Size of the beam in a beam-search. Larger the value - more accurate the result, more time required for search.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "SearchRequest": {
+        "description": "Search request",
+        "properties": {
+          "filter": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/Filter"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Look only for points which satisfies this conditions"
+          },
+          "params": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/SearchParams"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Additional search params"
+          },
+          "top": {
+            "description": "Max number of result to return",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "vector": {
+            "description": "Look for vectors closest to this",
+            "items": {
+              "format": "float",
+              "type": "number"
+            },
+            "type": "array"
+          },
+          "with_payload": {
+            "anyOf": [
+              {
+                "$ref": "#/components/schemas/WithPayloadInterface"
+              },
+              {
+                "nullable": true
+              }
+            ],
+            "description": "Payload interface"
+          }
+        },
+        "required": [
+          "top",
+          "vector"
+        ],
+        "type": "object"
+      },
+      "StorageOperations": {
+        "anyOf": [
+          {
+            "additionalProperties": false,
+            "description": "Create new collection and (optionally) specify index params",
+            "properties": {
+              "create_collection": {
+                "properties": {
+                  "distance": {
+                    "$ref": "#/components/schemas/Distance"
+                  },
+                  "hnsw_config": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/components/schemas/HnswConfigDiff"
+                      },
+                      {
+                        "nullable": true
+                      }
+                    ],
+                    "description": "Custom params for HNSW index. If none - values from service configuration file are used."
+                  },
+                  "name": {
+                    "type": "string"
+                  },
+                  "optimizers_config": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/components/schemas/OptimizersConfigDiff"
+                      },
+                      {
+                        "nullable": true
+                      }
+                    ],
+                    "description": "Custom params for Optimizers.  If none - values from service configuration file are used."
+                  },
+                  "vector_size": {
+                    "format": "uint",
+                    "minimum": 0,
+                    "type": "integer"
+                  },
+                  "wal_config": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/components/schemas/WalConfigDiff"
+                      },
+                      {
+                        "nullable": true
+                      }
+                    ],
+                    "description": "Custom params for WAL. If none - values from service configuration file are used."
+                  }
+                },
+                "required": [
+                  "distance",
+                  "name",
+                  "vector_size"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "create_collection"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Update parameters of the existing collection",
+            "properties": {
+              "update_collection": {
+                "properties": {
+                  "name": {
+                    "type": "string"
+                  },
+                  "optimizers_config": {
+                    "anyOf": [
+                      {
+                        "$ref": "#/components/schemas/OptimizersConfigDiff"
+                      },
+                      {
+                        "nullable": true
+                      }
+                    ],
+                    "description": "Custom params for Optimizers.  If none - values from service configuration file are used. This operation is blocking, it will only proceed ones all current optimizations are complete"
+                  }
+                },
+                "required": [
+                  "name"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "update_collection"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Delete collection with given name",
+            "properties": {
+              "delete_collection": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "delete_collection"
+            ],
+            "type": "object"
+          },
+          {
+            "additionalProperties": false,
+            "description": "Perform changes of collection aliases. Alias changes are atomic, meaning that no collection modifications can happen between alias operations.",
+            "properties": {
+              "change_aliases": {
+                "properties": {
+                  "actions": {
+                    "items": {
+                      "$ref": "#/components/schemas/AliasOperations"
+                    },
+                    "type": "array"
+                  }
+                },
+                "required": [
+                  "actions"
+                ],
+                "type": "object"
+              }
+            },
+            "required": [
+              "change_aliases"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "UpdateResult": {
+        "properties": {
+          "operation_id": {
+            "description": "Sequential number of the operation",
+            "format": "uint64",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "status": {
+            "$ref": "#/components/schemas/UpdateStatus"
+          }
+        },
+        "required": [
+          "operation_id",
+          "status"
+        ],
+        "type": "object"
+      },
+      "UpdateStatus": {
+        "enum": [
+          "acknowledged",
+          "completed"
+        ],
+        "type": "string"
+      },
+      "WalConfig": {
+        "properties": {
+          "wal_capacity_mb": {
+            "description": "Size of a single WAL segment in MB",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          },
+          "wal_segments_ahead": {
+            "description": "Number of WAL segments to create ahead of actually used ones",
+            "format": "uint",
+            "minimum": 0,
+            "type": "integer"
+          }
+        },
+        "required": [
+          "wal_capacity_mb",
+          "wal_segments_ahead"
+        ],
+        "type": "object"
+      },
+      "WalConfigDiff": {
+        "properties": {
+          "wal_capacity_mb": {
+            "description": "Size of a single WAL segment in MB",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "wal_segments_ahead": {
+            "description": "Number of WAL segments to create ahead of actually used ones",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "WithPayloadInterface": {
+        "anyOf": [
+          {
+            "type": "boolean"
+          },
+          {
+            "items": {
+              "type": "string"
+            },
+            "type": "array"
+          },
+          {
+            "$ref": "#/components/schemas/PayloadSelector"
+          }
+        ]
+      }
+    }
+  },
+  "externalDocs": {
+    "description": "Find out more about Qdrant aplications and demo",
+    "url": "demo.qdrant.tech"
+  },
+  "info": {
+    "contact": {
+      "email": "[email protected]"
+    },
+    "description": "\nAPI description for Qdrant vector search engine.\n\nThis document describes CRUD and search operations on collections of points (vectors with payload).\n\nQdrant supports any combinations of `should`, `must` and `must_not` conditions, which makes it possible to use in applications when object could not be described solely by vector. It could be location features, availability flags, and other custom properties businesses should take into account.\n## Examples\nThis examples cover the most basic use-cases - collection creation and basic vector search.\n### Create collection\nFirst - let's create a collection with dot-production metric.\n```\ncurl -X POST 'http://localhost:6333/collections' \\\n  -H 'Content-Type: application/json' \\\n  --data-raw '{\n      \"create_collection\": {\n          \"name\": \"test_collection\",\n          \"vector_size\": 4,\n          \"distance\": \"Dot\"\n      }\n  }'\n```\nExpected response:\n```\n{\n    \"result\": true,\n    \"status\": \"ok\",\n    \"time\": 0.031095451\n}\n```\nWe can ensure that collection was created:\n```\ncurl 'http://localhost:6333/collections/test_collection'\n```\nExpected response:\n```\n{\n  \"result\": {\n    \"status\": \"green\",\n    \"vectors_count\": 0,\n    \"segments_count\": 5,\n    \"disk_data_size\": 0,\n    \"ram_data_size\": 0,\n    \"config\": {\n      \"params\": {\n        \"vector_size\": 4,\n        \"distance\": \"Dot\"\n      },\n      \"hnsw_config\": {\n        \"m\": 16,\n        \"ef_construct\": 100,\n        \"full_scan_threshold\": 10000\n      },\n      \"optimizer_config\": {\n        \"deleted_threshold\": 0.2,\n        \"vacuum_min_vector_number\": 1000,\n        \"max_segment_number\": 5,\n        \"memmap_threshold\": 50000,\n        \"indexing_threshold\": 20000,\n        \"payload_indexing_threshold\": 10000,\n        \"flush_interval_sec\": 1\n      },\n      \"wal_config\": {\n        \"wal_capacity_mb\": 32,\n        \"wal_segments_ahead\": 0\n      }\n    }\n  },\n  \"status\": \"ok\",\n  \"time\": 2.1199e-05\n}\n```\n\n### Add points\nLet's now add vectors with some payload:\n```\ncurl -L -X POST 'http://localhost:6333/collections/test_collection?wait=true' \\ -H 'Content-Type: application/json' \\ --data-raw '{\n  \"upsert_points\": {\n    \"points\": [\n      {\"id\": 1, \"vector\": [0.05, 0.61, 0.76, 0.74], \"payload\": {\"city\": {\"type\": \"keyword\", \"value\": \"Berlin\"}}},\n      {\"id\": 2, \"vector\": [0.19, 0.81, 0.75, 0.11], \"payload\": {\"city\": {\"type\": \"keyword\", \"value\": [\"Berlin\", \"London\"] }}},\n      {\"id\": 3, \"vector\": [0.36, 0.55, 0.47, 0.94], \"payload\": {\"city\": {\"type\": \"keyword\", \"value\": [\"Berlin\", \"Moscow\"] }}},\n      {\"id\": 4, \"vector\": [0.18, 0.01, 0.85, 0.80], \"payload\": {\"city\": {\"type\": \"keyword\", \"value\": [\"London\", \"Moscow\"]}}},\n      {\"id\": 5, \"vector\": [0.24, 0.18, 0.22, 0.44], \"payload\": {\"count\": {\"type\": \"integer\", \"value\": [0]}}},\n      {\"id\": 6, \"vector\": [0.35, 0.08, 0.11, 0.44]}\n    ]\n  }\n}'\n```\nExpected response:\n```\n{\n    \"result\": {\n        \"operation_id\": 0,\n        \"status\": \"completed\"\n    },\n    \"status\": \"ok\",\n    \"time\": 0.000206061\n}\n```\n### Search with filtering\nLet's start with a basic request:\n```\ncurl -L -X POST 'http://localhost:6333/collections/test_collection/points/search' \\ -H 'Content-Type: application/json' \\ --data-raw '{\n    \"vector\": [0.2,0.1,0.9,0.7],\n    \"top\": 3\n}'\n```\nExpected response:\n```\n{\n    \"result\": [\n        { \"id\": 4, \"score\": 1.362 },\n        { \"id\": 1, \"score\": 1.273 },\n        { \"id\": 3, \"score\": 1.208 }\n    ],\n    \"status\": \"ok\",\n    \"time\": 0.000055785\n}\n```\nBut result is different if we add a filter:\n```\ncurl -L -X POST 'http://localhost:6333/collections/test_collection/points/search' \\ -H 'Content-Type: application/json' \\ --data-raw '{\n    \"filter\": {\n        \"should\": [\n            {\n                \"key\": \"city\",\n                \"match\": {\n                    \"keyword\": \"London\"\n                }\n            }\n        ]\n    },\n    \"vector\": [0.2, 0.1, 0.9, 0.7],\n    \"top\": 3\n}'\n```\nExpected response:\n```\n{\n    \"result\": [\n        { \"id\": 4, \"score\": 1.362 },\n        { \"id\": 2, \"score\": 0.871 }\n    ],\n    \"status\": \"ok\",\n    \"time\": 0.000093972\n}\n```\n",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "http://www.apache.org/licenses/LICENSE-2.0.html"
+    },
+    "title": "Qdrant API",
+    "version": "0.4.2"
+  },
+  "openapi": "3.0.1",
+  "paths": {
+    "/collections": {
+      "get": {
+        "operationId": "get_collections",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "$ref": "#/components/schemas/CollectionsResponse"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Get list of existing collections",
+        "tags": [
+          "collections"
+        ]
+      },
+      "post": {
+        "operationId": "update_collections",
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/StorageOperations"
+              }
+            }
+          },
+          "description": "Operation to perform on collections"
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "type": "boolean"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Perform update operation on collections",
+        "tags": [
+          "collections"
+        ]
+      }
+    },
+    "/collections/{name}": {
+      "get": {
+        "operationId": "get_collection",
+        "parameters": [
+          {
+            "description": "Name of the collection to retrieve",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "$ref": "#/components/schemas/CollectionInfo"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Get information about existing collection",
+        "tags": [
+          "collections"
+        ]
+      },
+      "post": {
+        "operationId": "update_points",
+        "parameters": [
+          {
+            "description": "Name of the collection to search in",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Wait for changes to actually happen? Default: false",
+            "in": "query",
+            "name": "wait",
+            "required": false,
+            "schema": {
+              "type": "boolean"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CollectionUpdateOperations"
+              }
+            }
+          },
+          "description": "Collection update operations"
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "$ref": "#/components/schemas/UpdateResult"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Update points (vectors, payloads, indexes) in collection",
+        "tags": [
+          "points"
+        ]
+      }
+    },
+    "/collections/{name}/points": {
+      "post": {
+        "operationId": "get_points",
+        "parameters": [
+          {
+            "description": "Name of the collection to retrieve from",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PointRequest"
+              }
+            }
+          },
+          "description": "List of points to retrieve"
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "items": {
+                        "$ref": "#/components/schemas/Record"
+                      },
+                      "type": "array"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Retrieve points by ids",
+        "tags": [
+          "points"
+        ]
+      }
+    },
+    "/collections/{name}/points/recommend": {
+      "post": {
+        "operationId": "recommend_points",
+        "parameters": [
+          {
+            "description": "Name of the collection to search in",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/RecommendRequest"
+              }
+            }
+          },
+          "description": "Request points based on positive and negative examples."
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "items": {
+                        "$ref": "#/components/schemas/ScoredPoint"
+                      },
+                      "type": "array"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Recommend points",
+        "tags": [
+          "points"
+        ]
+      }
+    },
+    "/collections/{name}/points/scroll": {
+      "post": {
+        "description": "Scroll request - paginate over all points which matches given condition",
+        "operationId": "scroll_points",
+        "parameters": [
+          {
+            "description": "Name of the collection to retrieve from",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ScrollRequest"
+              }
+            }
+          },
+          "description": "Pagination and filter parameters"
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "$ref": "#/components/schemas/ScrollResult"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Scroll points",
+        "tags": [
+          "points"
+        ]
+      }
+    },
+    "/collections/{name}/points/search": {
+      "post": {
+        "operationId": "search_points",
+        "parameters": [
+          {
+            "description": "Name of the collection to search in",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/SearchRequest"
+              }
+            }
+          },
+          "description": "Search request with optional filtering"
+        },
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "items": {
+                        "$ref": "#/components/schemas/ScoredPoint"
+                      },
+                      "type": "array"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Search points",
+        "tags": [
+          "points"
+        ]
+      }
+    },
+    "/collections/{name}/points/{id}": {
+      "get": {
+        "operationId": "get_point",
+        "parameters": [
+          {
+            "description": "Name of the collection to retrieve from",
+            "in": "path",
+            "name": "name",
+            "required": true,
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "description": "Id of the point",
+            "in": "path",
+            "name": "id",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "properties": {
+                    "result": {
+                      "$ref": "#/components/schemas/Record"
+                    },
+                    "status": {
+                      "enum": [
+                        "ok"
+                      ],
+                      "type": "string"
+                    },
+                    "time": {
+                      "description": "Time spent to process this request",
+                      "format": "float",
+                      "type": "number"
+                    }
+                  },
+                  "type": "object"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "default": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            },
+            "description": "error"
+          }
+        },
+        "summary": "Retrieve point by id",
+        "tags": [
+          "points"
+        ]
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "http://localhost:6333"
+    }
+  ],
+  "tags": [
+    {
+      "description": "Searchable collections of points.",
+      "name": "collections"
+    },
+    {
+      "description": "Float-point vectors with payload.",
+      "name": "points"
+    }
+  ]
+}