diff --git a/README.md b/README.md
index e9051b0fb..9899f2c59 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,44 @@
+# Index
+- [Running locally](#running-locally)
+  - [Prerequisites](#prerequisites)
+    - [Required](#required)
+    - [Needed only for development](#needed-only-for-development)
+      - [Updating npm dependencies via hugo](#updating-npm-dependencies-via-hugo)
+  - [Run](#run)
+  - [Run with drafts](#run-with-drafts)
+  - [Build css from scss](#build-css-from-scss)
+- [Content Management](#content-management)
+  - [Main Page](#main-page)
+    - [Customers/Partners Logos](#customerspartners-logos)
+  - [Articles](#articles)
+    - [Metadata](#metadata)
+    - [Preview image mechanism](#preview-image-mechanism)
+    - [Article preview](#article-preview)
+  - [Documentation](#documentation)
+    - [Metadata](#metadata-1)
+    - [Preview images for documentation pages](#preview-images-for-documentation-pages)
+    - [Documentation sidebar](#documentation-sidebar)
+      - [Delimiter](#delimiter)
+      - [External link](#external-link)
+      - [Params](#params)
+  - [Blog](#blog)
+    - [Images](#images)
+    - [Important notes](#important-notes)
+  - [Shortcodes 🧩🧩🧩](#shortcodes-)
+    - [Built-in shortcodes](#built-in-shortcodes)
+    - [Custom shortcodes](#custom-shortcodes)
+      - [🧩 Card](#-card)
+      - [🧩 Grid Row](#-grid-row)
+      - [🧩 Banner](#-banner)
+      - [🧩 Code Snippets Widget](#-code-snippets-widget)
+        - [📁 Directory Structure](#-directory-structure)
+        - [▶️ Example Usage](#-example-usage)
+        - [⚙️ Parameters](#-parameters)
+        - [⚠️ Notes](#-notes)
+        - [🚫 Limitations](#-limitations)
+
+
+
 # Running locally
 
 ## Prerequisites
@@ -271,7 +312,7 @@ In the blog post file, you'll see:
 - If a post has `featured: true` property in the front matter this post will appear in the "Features and News" blog section. Only the last 4 featured posts will be displayed in this section. Featured posts will not appear in the regular post list.
   - If there are more than 4 `featured: true` posts (where `draft: false`), the oldest post disappears from /blog.
 
-## Shortcodes
+## Shortcodes 🧩🧩🧩
 
 Hugo lets you use built-in and custom shortcodes to simplify the creation of content. Meanwhile, **keep in mind that shortcodes make the content less portable**. If you decide to move the content to another platform, you'll need to rewrite the shortcodes. **Avoid to overuse them.**
 
@@ -291,7 +332,7 @@ If you use a shortcode in your markdown file, but it fails to render, check if t
 
 You can find the list of available shortcodes in the `qdrant-landing/themes/qdrant/layouts/shortcodes` directory.
 
-#### Card
+#### 🧩 Card
 - Card - variant 1
 
   ![](readme-assets/shortcode-card-1.png)
@@ -323,7 +364,7 @@ col="6" >}}
 {{< /card >}}
 ```
 
-Options for card shortcode:
+Parameters for card shortcode:
 - `title` - required
 - `link` -required
 - `image` - optional, default null
@@ -333,7 +374,9 @@ Options for card shortcode:
 
 Card variant 1 is the default; you can optionally change the icon and type, if you use `image` option, you will get variant 2, type and icon will be ignored even if given.
 
-#### Grid Row
+<hr>
+
+#### 🧩 Grid Row
 
 Cards should be enclosed in a row shortcode if you want to have more than one card in a row.
 
@@ -359,7 +402,9 @@ Example:
 
 Each card will take up half of the row in the example above.
 
-#### Banner
+<hr>
+
+#### 🧩 Banner
 
 ![](readme-assets/shortcode-banner.png)
 
@@ -370,11 +415,55 @@ Example:
 {{< /banner >}}
 ```
 
-Options for banner shortcode:
+Parameters for banner shortcode:
 - `link` - required
 - `cta` - optional, default "Get Started"
 - `image` - optional, default "/img/rocket.svg"
 
+<hr>
+
+#### 🧩 Code Snippets Widget
+
+![](readme-assets/shortcode-snippets.png)
+
+This shortcode renders a code snippets widget from a specified path.
+Use it when you want to manage code examples as a collection of separate Markdown files.
+
+##### 📁 Directory Structure
+Place all code snippets for a single widget into one directory. Each file should be named after the programming language it represents:
+
+```
+points-id/
+├── http.md
+├── python.md
+├── go.md
+```
+File names are used for sorting. It's recommended to name files according to the language they contain (e.g., python.md, go.md). Sorting is controlled by the order parameter or the snippetsOrder parameter (see below).
+
+Each file should contain a code snippet in a fenced code block (```).
+
+##### ▶️ Example Usage
+``` hugo
+{{< code-snippet path="/documentation/headless/snippets/points-id/" order="python http go" >}}
+``` 
+
+##### ⚙️ Parameters
+- `path` (required) – Path to the directory (inside content/) containing the snippet files.
+- `order` (optional) – Space-separated list of snippet names to display first. Remaining files will be rendered in the order they appear in the directory. Sorting is based on file names (without .md).
+
+You can also define a global default snippet order using the snippetsOrder parameter in the relevant section’s _index.md.
+
+##### ⚠️ Notes
+**Important:** Turn off rendering for the snippets directory if it's not already disabled in its parent section. Otherwise, Hugo will attempt to generate standalone pages for these files.
+
+You can include multiple snippets in a single Markdown file, but in that case, the order parameter has no effect—they will render in the order they appear in the file.
+
+##### 🚫 Limitations
+Snippet files must not contain front matter (---). Each code snippet should be a fenced code block (```).
+
+The snippetsOrder parameter only works at the section level or deeper. If you're adding snippets to a section for the first time, make sure to define snippetsOrder in that section’s or a child section’s _index.md.
+
+
 ## SEO
 
 ### Structured data (Schema.org, JSON-LD)
@@ -419,3 +508,5 @@ If you want to add a new schema, create a new JSON file in the `qdrant-landing/a
 When use `seo_schema` and `seo_schema_json` together, `seo_schema` will be used additionally to `seo_schema_json` adding the second <script> tag with the `seo_schema` value.
 
 Use `seo_schema_json` if you want to reuse the same schema for multiple pages to avoid duplication and make it easier to maintain.
+
+[To Index](#index)
\ No newline at end of file
diff --git a/automation/describe-snippets.py b/automation/describe-snippets.py
new file mode 100644
index 000000000..d91496da1
--- /dev/null
+++ b/automation/describe-snippets.py
@@ -0,0 +1,124 @@
+"""
+This script should generate a description for snippets using OpenAI API.
+
+Given snippet context and snippet code, the script should generate a short description of the snippet.
+
+Description will be later used for semantic search of snippets.
+
+
+
+"""
+
+import os
+from typing import List, Tuple
+from openai import OpenAI
+
+
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+client = OpenAI(api_key=OPENAI_API_KEY)
+
+if not OPENAI_API_KEY:
+    raise ValueError("OPENAI_API_KEY is not set")
+
+
+
+def describe_snippet(context: str, code: str, category: str) -> str:
+    """
+    Generate a description for a snippet using OpenAI API.
+    """
+    response = client.chat.completions.create(model="gpt-3.5-turbo",
+    messages=[
+        {"role": "system", "content": "You are a helpful assistant that generates descriptions for code snippets. Ignore the format of the code and focus more on semantic meaning of the code. Don't mention HTTP, JSON or Python in the description."},
+        {"role": "user", "content": f"Category: {category}\n\nContext: {context}\n\nCode: {code}"},
+    ])
+    return response.choices[0].message.content  
+
+
+def read_snippet(dir: str) -> Tuple[str, str]:
+    """
+    Read a snippet from a file.
+    """
+
+    snippet_path_http = os.path.join(dir, "http.md")
+    snippet_path_python = os.path.join(dir, "python.md")
+
+    if os.path.exists(snippet_path_http):
+        snippet_path = snippet_path_http
+    elif os.path.exists(snippet_path_python):
+        snippet_path = snippet_path_python
+    else:
+        raise ValueError(f"Snippet file not found in {dir}")
+    
+    description_path = os.path.join(dir, "_index.md")
+
+    if not os.path.exists(snippet_path) or not os.path.exists(description_path):
+        raise ValueError(f"Snippet or description file not found in {dir}")
+
+    with open(snippet_path, "r") as f:
+        snippet = f.read()
+
+    with open(description_path, "r") as f:
+        description = f.read()
+
+    return snippet, description
+
+
+def write_description(dir: str):
+
+    description_path = os.path.join(dir, "_description.md")
+
+    if os.path.exists(description_path):
+        print(f"Description already exists in {description_path}")
+        return
+
+    snippet, description = read_snippet(dir)
+
+    category = dir.split("/")[-2:]
+
+    description = describe_snippet(snippet, description, category)
+
+    with open(description_path, "w") as f:
+        f.write(description)
+
+
+def get_all_snippets_dirs(root_dir: str) -> List[str]:
+    """
+    Get all snippets dirs in the root directory.
+    
+    Find all sub-sub-directories in the root directory.
+    
+    """
+
+    snippets_dirs = []
+
+    for root, dirs, files in os.walk(root_dir):
+        for dir in dirs:
+            
+            # Check that `_index.md` file exists in the directory
+            if not os.path.exists(os.path.join(root, dir, "_index.md")):
+                continue
+
+            snippets_dirs.append(os.path.join(root, dir))
+    return snippets_dirs
+
+
+
+
+def main():
+    """
+    Main function to run the script.
+    """
+
+    root_dir = "qdrant-landing/content/documentation/headless/snippets/"
+
+    snippets_dirs = get_all_snippets_dirs(root_dir)
+
+    for snippet_dir in snippets_dirs:
+        print(snippet_dir)
+        write_description(snippet_dir)
+
+
+
+if __name__ == "__main__":
+    main()
diff --git a/automation/extract-snippets.py b/automation/extract-snippets.py
new file mode 100644
index 000000000..a4fdb4671
--- /dev/null
+++ b/automation/extract-snippets.py
@@ -0,0 +1,296 @@
+"""
+A script which reads markdown file and extracts snippets from it into a separate folder
+grouped by the language and category.
+
+
+Example.md:
+
+
+## Create collection with qdrant
+
+How to create a collection with qdrant:
+
+
+```http
+PUT /collections/my_collection
+{
+    "vector_config": {
+        "size": 1536,
+        "distance": "Cosine"
+    }
+}
+```
+
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="my_collection",
+    vectors_config=VectorParams(size=1536, distance="Cosine"),
+)
+```
+
+
+---
+
+Now, the script should extract the snippets into a separate folder grouped by the language and "category".
+Category should be asked from the user, it may contain 2 parts - top-level category and sub-category.
+
+For example: `create-collection/simple-collection`
+
+This will create a folder `create-collection` and inside it will create a folder `simple-collection`.
+All snippets should be placed into this folder with names `http.md`, `python.md`, etc.
+
+Path to the root folder is defined in the `SNIPPETS_ROOT` variable.
+
+Instead of providing the category, user can skip it, in this case snippets should be ignored.
+
+If the category is provided, the script should create a folder for the category if it doesn't exist.
+
+Snippets in the original file should be replaced with the link to the new file, which looks like this:
+
+```
+{{< code-snippet path="{SNIPPERS_MD_ROOT}/{CATEGORY}/{SUBCATEGORY}/" >}}
+```
+
+"""
+
+import dataclasses
+import re
+import os
+import argparse
+from typing import Optional
+
+
+SNIPPETS_ROOT = "qdrant-landing/content/documentation/headless/snippets/"
+SNIPPERS_MD_ROOT = "/documentation/headless/snippets"
+
+
+@dataclasses.dataclass
+class Snippet:
+    language: str
+    content: str
+
+
+@dataclasses.dataclass
+class SnippetsGroup:
+    # Content of the markdown file before the snippets
+    # Up to the first other snippet(excluding) or header(including)
+    context: str
+    raw_content: str
+    snippets: list[Snippet]
+    path: Optional[str] = None
+
+
+def extract_snippets(markdown_content: str) -> list[SnippetsGroup]:
+    """
+    Extracts snippets from the markdown content.
+
+    Snippet group is a sequence of code blocks, not separated by other text.
+    Whitespace-only lines between snippets are allowed.
+    """
+    # Pattern to match code blocks with their language and content
+    pattern = r'```(\w+)\n(.*?)\n```'
+    matches = list(re.finditer(pattern, markdown_content, re.DOTALL))
+    
+    if not matches:
+        return []
+    
+    # Pattern to match headers
+    header_pattern = r'^#{1,6}\s+.*$'
+    
+    groups = []
+    current_group = []
+    current_raw_content = ""
+    
+    for i, match in enumerate(matches):
+        if not current_group:
+            # Start a new group
+            current_group = [match]
+            current_raw_content = match.group(0)
+            
+            # Find the context for this group
+            # Look for the previous header or snippet
+            start_pos = 0
+            if i > 0:
+                start_pos = matches[i - 1].end()
+            
+            # Find the last header before this snippet
+            context_start = start_pos
+            for header_match in re.finditer(header_pattern, markdown_content[start_pos:match.start()], re.MULTILINE):
+                context_start = start_pos + header_match.start()
+            
+            context = markdown_content[context_start:match.start()]
+        else:
+            # Check if there's only whitespace between this match and the previous one
+            last_match = matches[i - 1]
+            between_content = markdown_content[last_match.end():match.start()]
+            
+            # Check if the content between matches contains only whitespace
+            if re.match(r'^\s*$', between_content):
+                current_raw_content += between_content + match.group(0)
+                current_group.append(match)
+            else:
+                # There's non-whitespace content between matches, finalize current group
+                groups.append(SnippetsGroup(
+                    context=context,
+                    raw_content=current_raw_content,
+                    snippets=[Snippet(language=m.group(1), content=m.group(2)) for m in current_group]
+                ))
+                # Start a new group
+                current_group = [match]
+                current_raw_content = match.group(0)
+                
+                # Find the context for the new group
+                # Look for the previous header or snippet
+                start_pos = matches[i - 1].end()
+                
+                # Find the last header before this snippet
+                context_start = start_pos
+                for header_match in re.finditer(header_pattern, markdown_content[start_pos:match.start()], re.MULTILINE):
+                    context_start = start_pos + header_match.start()
+                
+                context = markdown_content[context_start:match.start()]
+    
+    # Add the last group if it exists
+    if current_group:
+        groups.append(SnippetsGroup(
+            context=context,
+            raw_content=current_raw_content,
+            snippets=[Snippet(language=m.group(1), content=m.group(2)) for m in current_group]
+        ))
+    
+    return groups
+
+
+def get_existing_categories() -> list[str]:
+    """
+    Returns a list of existing categories. List them from the root folder.
+    """
+    categories = []
+    for file in os.listdir(SNIPPETS_ROOT):
+        if os.path.isdir(os.path.join(SNIPPETS_ROOT, file)):
+            categories.append(file)
+
+    categories.sort()
+    return categories
+
+
+def get_existing_sub_categories(category: str) -> list[str]:
+    """
+    Returns a list of existing sub-categories for a given category.
+    """
+    sub_categories = os.listdir(os.path.join(SNIPPETS_ROOT, category))
+    sub_categories.sort()
+    return sub_categories
+
+
+def save_snippets(snippets: list[SnippetsGroup]):
+    """
+    For each snippet:
+    - Show first snippet content
+    - Show all categories which are already created
+    - Skip if category is not provided
+    - Ask user to select one of the categories or create a new one
+    - Create a new folder for the category if it doesn't exist
+    - Ask a sub-category
+    - Create a new folder for the sub-category if it doesn't exist
+    - Save the snippets into the folder
+    """
+
+    for group in snippets:
+        print("----------------------------")
+        print(group.context)
+        print("")
+        print(group.snippets[0].content)
+        print("----------------------------")
+
+        existing_categories = get_existing_categories()
+
+        print("Existing categories:")
+        for i, category in enumerate(existing_categories):
+            print(f"{i}. {category}")
+
+        category = input("Enter category: ")\
+        
+        if category == "":
+            print("Skipping snippet")
+            continue
+
+        if category not in existing_categories:
+            os.makedirs(os.path.join(SNIPPETS_ROOT, category), exist_ok=True)
+
+        existing_sub_categories = get_existing_sub_categories(category)
+
+        print("Existing sub-categories:")
+        for i, sub_category in enumerate(existing_sub_categories):
+            print(f"{i}. {sub_category}")
+
+        sub_category = input("Enter sub-category: ")
+        if sub_category == "":
+            print("Skipping snippet")
+            continue
+
+        sub_category_path = os.path.join(SNIPPETS_ROOT, category, sub_category)
+
+        group.path = os.path.join(SNIPPERS_MD_ROOT, category, sub_category) + "/"
+
+        if sub_category not in existing_sub_categories:
+            os.makedirs(sub_category_path, exist_ok=True)
+        else:
+            overwrite = input(f"Sub-category '{sub_category}' already exists. Do you want to overwrite? (y/N): ")
+            if overwrite.lower() != 'y':
+                print("Skipping snippet") 
+                continue
+
+        for snippet in group.snippets:
+            with open(os.path.join(sub_category_path, f"{snippet.language}.md"), "w") as f:
+                # Save snippet in markdown format
+                f.write(f"```{snippet.language}\n")
+                f.write(snippet.content)
+                f.write("\n```\n")
+        
+        # Save context into `_index.md` file
+        with open(os.path.join(sub_category_path, "_index.md"), "w") as f:
+            f.write(group.context)
+
+    
+    return snippets
+
+
+def replace_snippets(markdown_content: str, snippets: list[SnippetsGroup]):
+    """
+    Replaces snippets in the markdown content with the links to the new files.
+    """
+    for group in snippets:
+        if group.path is None:
+            continue
+        markdown_content = markdown_content.replace(group.raw_content, '{{< code-snippet path="'  + group.path + '" >}}')
+    return markdown_content
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Extract code snippets from markdown file.')
+    parser.add_argument('input_file', help='Path to the input markdown file')
+    parser.add_argument('--output', '-o', help='Path to the output file (default: input_file.tmp)')
+    args = parser.parse_args()
+
+    input_file = args.input_file
+    output_file = args.output or f"{input_file}.tmp"
+
+    with open(input_file, "r") as f:
+        content = f.read()
+
+    snippets = extract_snippets(content)
+    snippets = save_snippets(snippets)
+
+    replaced_content = replace_snippets(content, snippets)
+
+    with open(output_file, "w") as f:
+        f.write(replaced_content)
+
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/concepts/collections.md b/qdrant-landing/content/documentation/concepts/collections.md
index 3e9748027..7a5bb3150 100644
--- a/qdrant-landing/content/documentation/concepts/collections.md
+++ b/qdrant-landing/content/documentation/concepts/collections.md
@@ -35,107 +35,7 @@ These settings can be changed at any time by a corresponding request.
 ## Create a collection
 
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 300,
-      "distance": "Cosine"
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-      "size": 300,
-      "distance": "Cosine"
-    } 
-  }'
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=100, distance=models.Distance.COSINE),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: { size: 100, distance: "Cosine" },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{CreateCollectionBuilder, VectorParamsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(100, Distance::Cosine)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client = new QdrantClient(
-    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.createCollectionAsync("{collection_name}",
-        VectorParams.newBuilder().setDistance(Distance.Cosine).setSize(100).build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 100, Distance = Distance.Cosine }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     100,
-		Distance: qdrant.Distance_Cosine,
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/simple/" >}}
 
 In addition to the required options, you can also specify custom values for the following collection options:
 
@@ -173,132 +73,7 @@ Make sure the vectors have the same `size` and `distance` function when setting
 code, `"size": 300` and `"distance": "Cosine"`.
 
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 100,
-      "distance": "Cosine"
-    },
-    "init_from": {
-       "collection": "{from_collection_name}"
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-      "size": 300,
-      "distance": "Cosine"
-    },
-    "init_from": {
-       "collection": {from_collection_name}
-    }
-  }'
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=100, distance=models.Distance.COSINE),
-    init_from=models.InitFrom(collection="{from_collection_name}"),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: { size: 100, distance: "Cosine" },
-  init_from: { collection: "{from_collection_name}" },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{CreateCollectionBuilder, Distance, VectorParamsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(100, Distance::Cosine))
-            .init_from_collection("{from_collection_name}"),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(100)
-                            .setDistance(Distance.Cosine)
-                            .build()))
-            .setInitFromCollection("{from_collection_name}")
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 100, Distance = Distance.Cosine },
-	initFromCollection: "{from_collection_name}"
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     100,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	InitFromCollection: qdrant.PtrOf("{from_collection_name}"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/init-from/" >}}
 
 ### Collection with multiple vectors
 
@@ -310,157 +85,7 @@ To distinguish vectors in one record, they should have a unique name defined whe
 Each named vector in this mode has its distance and size:
 
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-        "image": {
-            "size": 4,
-            "distance": "Dot"
-        },
-        "text": {
-            "size": 8,
-            "distance": "Cosine"
-        }
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-        "image": {
-            "size": 4,
-            "distance": "Dot"
-        },
-        "text": {
-            "size": 8,
-            "distance": "Cosine"
-        }
-      }
-    }'
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={
-        "image": models.VectorParams(size=4, distance=models.Distance.DOT),
-        "text": models.VectorParams(size=8, distance=models.Distance.COSINE),
-    },
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    image: { size: 4, distance: "Dot" },
-    text: { size: 8, distance: "Cosine" },
-  },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, VectorParamsBuilder, VectorsConfigBuilder,
-};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut vectors_config = VectorsConfigBuilder::default();
-vectors_config
-    .add_named_vector_params("image", VectorParamsBuilder::new(4, Distance::Dot).build());
-vectors_config.add_named_vector_params(
-    "text",
-    VectorParamsBuilder::new(8, Distance::Cosine).build(),
-);
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}").vectors_config(vectors_config),
-    )
-    .await?;
-```
-
-```java
-import java.util.Map;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.VectorParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        "{collection_name}",
-        Map.of(
-            "image", VectorParams.newBuilder().setSize(4).setDistance(Distance.Dot).build(),
-            "text",
-                VectorParams.newBuilder().setSize(8).setDistance(Distance.Cosine).build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParamsMap
-	{
-		Map =
-		{
-			["image"] = new VectorParams { Size = 4, Distance = Distance.Dot },
-			["text"] = new VectorParams { Size = 8, Distance = Distance.Cosine },
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfigMap(
-		map[string]*qdrant.VectorParams{
-			"image": {
-				Size:     4,
-				Distance: qdrant.Distance_Dot,
-			},
-			"text": {
-				Size:     8,
-				Distance: qdrant.Distance_Cosine,
-			},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/multiple-vectors/" >}}
 
 For rare use cases, it is possible to create a collection without any vector storage.
 
@@ -491,127 +116,7 @@ Qdrant has direct support for uint8 embeddings, which you can also use in combin
 
 To create a collection with uint8 embeddings, you can use the following configuration:
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 1024,
-      "distance": "Cosine",
-      "datatype": "uint8"
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-      "size": 1024,
-      "distance": "Cosine",
-      "datatype": "uint8"
-    }
-  }'
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(
-        size=1024,
-        distance=models.Distance.COSINE,
-        datatype=models.Datatype.UINT8,
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    image: { size: 1024, distance: "Cosine", datatype: "uint8" },
-  },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Datatype, Distance, VectorParamsBuilder,
-};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}").vectors_config(
-            VectorParamsBuilder::new(1024, Distance::Cosine).datatype(Datatype::Uint8),
-        ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.grpc.Collections.Datatype;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.VectorParams;
-
-QdrantClient client = new QdrantClient(
-    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync("{collection_name}",
-        VectorParams.newBuilder()
-            .setSize(1024)
-            .setDistance(Distance.Cosine)
-            .setDatatype(Datatype.Uint8)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  vectorsConfig: new VectorParams {
-    Size = 1024, Distance = Distance.Cosine, Datatype = Datatype.Uint8
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     1024,
-		Distance: qdrant.Distance_Cosine,
-		Datatype: qdrant.Datatype_Uint8.Enum(),
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/datatype-uint8/" >}}
 
 Vectors with `uint8` datatype are stored in a more compact format, which can save memory and improve search speed at the cost of some precision.
 If you choose to use the `uint8` datatype, elements of the vector will be stored as unsigned 8-bit integers, which can take values **from 0 to 255**.
@@ -630,125 +135,7 @@ Collections can contain sparse vectors as additional [named vectors](#collection
 Unlike dense vectors, sparse vectors must be named.
 And additionally, sparse vectors and dense vectors must have different names within a collection.
 
-```http
-PUT /collections/{collection_name}
-{
-    "sparse_vectors": {
-        "text": { }
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "sparse_vectors": {
-        "text": { }
-    }
-  }'
-```
-
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={},
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(),
-    },
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  sparse_vectors: {
-    text: { },
-  },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
-};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
-
-sparse_vector_config.add_named_vector_params("text", SparseVectorParamsBuilder::default());
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .sparse_vectors_config(sparse_vector_config),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setSparseVectorsConfig(
-                SparseVectorConfig.newBuilder()
-                    .putMap("text", SparseVectorParams.getDefaultInstance()))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	sparseVectorsConfig: ("text", new SparseVectorParams())
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text": {},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/sparse-vector/" >}}
 
 Outside of a unique name, there are no required configuration parameters for sparse vectors.
 
@@ -760,75 +147,11 @@ However, there are optional parameters to tune the underlying [sparse vector ind
 
 *Available as of v1.8.0*
 
-```http
-GET http://localhost:6333/collections/{collection_name}/exists
-```
-
-```bash
-curl -X GET http://localhost:6333/collections/{collection_name}/exists
-```
-
-```python
-client.collection_exists(collection_name="{collection_name}")
-```
-
-```typescript
-client.collectionExists("{collection_name}");
-```
-
-```rust
-client.collection_exists("{collection_name}").await?;
-```
-
-```java
-client.collectionExistsAsync("{collection_name}").get();
-```
-
-```csharp
-await client.CollectionExistsAsync("{collection_name}");
-```
-
-```go
-import "context"
-
-client.CollectionExists(context.Background(), "my_collection")
-```
+{{< code-snippet path="/documentation/headless/snippets/check-collection-exists/simple/" >}}
 
 ### Delete collection
 
-```http
-DELETE http://localhost:6333/collections/{collection_name}
-```
-
-```bash
-curl -X DELETE http://localhost:6333/collections/{collection_name}
-```
-
-```python
-client.delete_collection(collection_name="{collection_name}")
-```
-
-```typescript
-client.deleteCollection("{collection_name}");
-```
-
-```rust
-client.delete_collection("{collection_name}").await?;
-```
-
-```java
-client.deleteCollectionAsync("{collection_name}").get();
-```
-
-```csharp
-await client.DeleteCollectionAsync("{collection_name}");
-```
-
-```go
-import "context"
-
-client.DeleteCollection(context.Background(), "{collection_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-collection/simple/" >}}
 
 ### Update collection parameters
 
@@ -838,95 +161,7 @@ As a result, you will not waste extra computation resources on rebuilding the in
 
 The following command enables indexing for segments that have more than 10000 kB of vectors stored:
 
-```http
-PATCH /collections/{collection_name}
-{
-    "optimizers_config": {
-        "indexing_threshold": 10000
-    }
-}
-```
-
-```bash
-curl -X PATCH http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "optimizers_config": {
-        "indexing_threshold": 10000
-    }
-  }'
-```
-
-```python
-client.update_collection(
-    collection_name="{collection_name}",
-    optimizers_config=models.OptimizersConfigDiff(indexing_threshold=10000),
-)
-```
-
-```typescript
-client.updateCollection("{collection_name}", {
-  optimizers_config: {
-    indexing_threshold: 10000,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{OptimizersConfigDiffBuilder, UpdateCollectionBuilder};
-
-client
-    .update_collection(
-        UpdateCollectionBuilder::new("{collection_name}").optimizers_config(
-            OptimizersConfigDiffBuilder::default().indexing_threshold(10000),
-        ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.UpdateCollection;
-
-client.updateCollectionAsync(
-    UpdateCollection.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setOptimizersConfig(
-            OptimizersConfigDiff.newBuilder().setIndexingThreshold(10000).build())
-        .build());
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpdateCollectionAsync(
-	collectionName: "{collection_name}",
-	optimizersConfig: new OptimizersConfigDiff { IndexingThreshold = 10000 }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
-	CollectionName: "{collection_name}",
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{
-		IndexingThreshold: qdrant.PtrOf(uint64(10000)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/update-collection/simple/" >}}
 
 The following parameters can be updated:
 
@@ -958,28 +193,7 @@ To put vector data on disk for a collection that **does not have** named vectors
 use `""` as name:
 
 
-```http
-PATCH /collections/{collection_name}
-{
-    "vectors": {
-        "": {
-            "on_disk": true
-        }
-    }
-}
-```
-
-```bash
-curl -X PATCH http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-        "": { 
-            "on_disk": true 
-      }
-    }
-  }'
-```
+{{< code-snippet path="/documentation/headless/snippets/update-collection/vectors-to-disk-default/" >}}
 
 
 To put vector data on disk for a collection that **does have** named vectors:
@@ -987,333 +201,20 @@ To put vector data on disk for a collection that **does have** named vectors:
 Note: To create a vector name, follow the procedure from our [Points](/documentation/concepts/points/#create-vector-name).
 
 
-```http
-PATCH /collections/{collection_name}
-{
-    "vectors": {
-        "my_vector": {
-            "on_disk": true
-        }
-    }
-}
-```
-
-```bash
-curl -X PATCH http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-        "my_vector": { 
-           "on_disk": true 
-      }
-    }
-  }'
-```
+{{< code-snippet path="/documentation/headless/snippets/update-collection/vectors-to-disk-named/" >}}
 
 In the following example the HNSW index and quantization parameters are updated,
 both for the whole collection, and for `my_vector` specifically:
 
 
-```http
-PATCH /collections/{collection_name}
-{
-    "vectors": {
-        "my_vector": {
-            "hnsw_config": {
-                "m": 32,
-                "ef_construct": 123
-            },
-            "quantization_config": {
-                "product": {
-                    "compression": "x32",
-                    "always_ram": true
-                }
-            },
-            "on_disk": true
-        }
-    },
-    "hnsw_config": {
-        "ef_construct": 123
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "quantile": 0.8,
-            "always_ram": false
-        }
-    }
-}
-```
-
-```bash
-curl -X PATCH http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "vectors": {
-        "my_vector": {
-            "hnsw_config": {
-                "m": 32,
-                "ef_construct": 123
-            },
-            "quantization_config": {
-                "product": {
-                    "compression": "x32",
-                    "always_ram": true
-                }
-            },
-            "on_disk": true
-        }
-    },
-    "hnsw_config": {
-        "ef_construct": 123
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "quantile": 0.8,
-            "always_ram": false
-        }
-    }
-}'
-```
-
-```python
-client.update_collection(
-    collection_name="{collection_name}",
-    vectors_config={
-        "my_vector": models.VectorParamsDiff(
-            hnsw_config=models.HnswConfigDiff(
-                m=32,
-                ef_construct=123,
-            ),
-            quantization_config=models.ProductQuantization(
-                product=models.ProductQuantizationConfig(
-                    compression=models.CompressionRatio.X32,
-                    always_ram=True,
-                ),
-            ),
-            on_disk=True,
-        ),
-    },
-    hnsw_config=models.HnswConfigDiff(
-        ef_construct=123,
-    ),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            quantile=0.8,
-            always_ram=False,
-        ),
-    ),
-)
-```
-
-```typescript
-client.updateCollection("{collection_name}", {
-  vectors: {
-    my_vector: {
-      hnsw_config: {
-        m: 32,
-        ef_construct: 123,
-      },
-      quantization_config: {
-        product: {
-          compression: "x32",
-          always_ram: true,
-        },
-      },
-      on_disk: true,
-    },
-  },
-  hnsw_config: {
-    ef_construct: 123,
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      quantile: 0.8,
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use std::collections::HashMap;
-
-use qdrant_client::qdrant::{
-    quantization_config_diff::Quantization, vectors_config_diff::Config, HnswConfigDiffBuilder,
-    QuantizationType, ScalarQuantizationBuilder, UpdateCollectionBuilder, VectorParamsDiffBuilder,
-    VectorParamsDiffMap,
-};
-
-client
-    .update_collection(
-        UpdateCollectionBuilder::new("{collection_name}")
-            .hnsw_config(HnswConfigDiffBuilder::default().ef_construct(123))
-            .vectors_config(Config::ParamsMap(VectorParamsDiffMap {
-                map: HashMap::from([(
-                    ("my_vector".into()),
-                    VectorParamsDiffBuilder::default()
-                        .hnsw_config(HnswConfigDiffBuilder::default().m(32).ef_construct(123))
-                        .build(),
-                )]),
-            }))
-            .quantization_config(Quantization::Scalar(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .quantile(0.8)
-                    .always_ram(true)
-                    .build(),
-            )),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Collections.HnswConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.UpdateCollection;
-import io.qdrant.client.grpc.Collections.VectorParamsDiff;
-import io.qdrant.client.grpc.Collections.VectorParamsDiffMap;
-import io.qdrant.client.grpc.Collections.VectorsConfigDiff;
-
-client
-    .updateCollectionAsync(
-        UpdateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setHnswConfig(HnswConfigDiff.newBuilder().setEfConstruct(123).build())
-            .setVectorsConfig(
-                VectorsConfigDiff.newBuilder()
-                    .setParamsMap(
-                        VectorParamsDiffMap.newBuilder()
-                            .putMap(
-                                "my_vector",
-                                VectorParamsDiff.newBuilder()
-                                    .setHnswConfig(
-                                        HnswConfigDiff.newBuilder()
-                                            .setM(3)
-                                            .setEfConstruct(123)
-                                            .build())
-                                    .build())))
-            .setQuantizationConfig(
-                QuantizationConfigDiff.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setQuantile(0.8f)
-                            .setAlwaysRam(true)
-                            .build()))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpdateCollectionAsync(
-	collectionName: "{collection_name}",
-	hnswConfig: new HnswConfigDiff { EfConstruct = 123 },
-	vectorsConfig: new VectorParamsDiffMap
-	{
-		Map =
-		{
-			{
-				"my_vector",
-				new VectorParamsDiff
-				{
-					HnswConfig = new HnswConfigDiff { M = 3, EfConstruct = 123 }
-				}
-			}
-		}
-	},
-	quantizationConfig: new QuantizationConfigDiff
-	{
-		Scalar = new ScalarQuantization
-		{
-			Type = QuantizationType.Int8,
-			Quantile = 0.8f,
-			AlwaysRam = true
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfigDiffMap(
-		map[string]*qdrant.VectorParamsDiff{
-			"my_vector": {
-				HnswConfig: &qdrant.HnswConfigDiff{
-					M:           qdrant.PtrOf(uint64(3)),
-					EfConstruct: qdrant.PtrOf(uint64(123)),
-				},
-			},
-		}),
-	QuantizationConfig: qdrant.NewQuantizationDiffScalar(
-		&qdrant.ScalarQuantization{
-			Type:      qdrant.QuantizationType_Int8,
-			Quantile:  qdrant.PtrOf(float32(0.8)),
-			AlwaysRam: qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/update-collection/hnsw-and-quantization/" >}}
 
 ## Collection info
 
 Qdrant allows determining the configuration parameters of an existing collection to better understand how the points are
 distributed and indexed.
 
-```http
-GET /collections/{collection_name}
-```
-
-```bash
-curl -X GET http://localhost:6333/collections/{collection_name}
-```
-
-```python
-client.get_collection(collection_name="{collection_name}")
-```
-
-```typescript
-client.getCollection("{collection_name}");
-```
-
-```rust
-client.collection_info("{collection_name}").await?;
-```
-
-```java
-client.getCollectionInfoAsync("{collection_name}").get();
-```
-
-```csharp
-await client.GetCollectionInfoAsync("{collection_name}");
-```
-
-```go
-import "context"
-
-client.GetCollectionInfo(context.Background(), "{collection_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-info/simple/" >}}
 
 <details>
 <summary>Expected result</summary>
@@ -1392,86 +293,7 @@ send any update operation to trigger and start the optimizations again.
 
 For example:
 
-```http
-PATCH /collections/{collection_name}
-{
-    "optimizers_config": {}
-}
-```
-
-```bash
-curl -X PATCH http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "optimizers_config": {}
-  }'
-```
-
-```python
-client.update_collection(
-    collection_name="{collection_name}",
-    optimizer_config=models.OptimizersConfigDiff(),
-)
-```
-
-```typescript
-client.updateCollection("{collection_name}", {
-  optimizers_config: {},
-});
-```
-
-```rust
-use qdrant_client::qdrant::{OptimizersConfigDiffBuilder, UpdateCollectionBuilder};
-
-client
-    .update_collection(
-        UpdateCollectionBuilder::new("{collection_name}")
-            .optimizers_config(OptimizersConfigDiffBuilder::default()),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.UpdateCollection;
-
-client.updateCollectionAsync(
-    UpdateCollection.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setOptimizersConfig(
-            OptimizersConfigDiff.getDefaultInstance())
-        .build());
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpdateCollectionAsync(
-	collectionName: "{collection_name}",
-	optimizersConfig: new OptimizersConfigDiff { }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
-	CollectionName:   "{collection_name}",
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/update-collection/trigger-indexing/" >}}
 
 Alternatively you may use the `Trigger Optimizers` button in the [Qdrant Web UI](/documentation/web-ui/).
 It is shown next to the grey collection status on the collection info page.
@@ -1528,459 +350,27 @@ Since all changes of aliases happen atomically, no concurrent requests will be a
 
 ### Create alias
 
-```http
-POST /collections/aliases
-{
-    "actions": [
-        {
-            "create_alias": {
-                "collection_name": "example_collection",
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}
-```
-
-```bash
-curl -X POST http://localhost:6333/collections/aliases \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "actions": [
-        {
-            "create_alias": {
-                "collection_name": "example_collection",
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}'
-```
-
-```python
-client.update_collection_aliases(
-    change_aliases_operations=[
-        models.CreateAliasOperation(
-            create_alias=models.CreateAlias(
-                collection_name="example_collection", alias_name="production_collection"
-            )
-        )
-    ]
-)
-```
-
-```typescript
-client.updateCollectionAliases({
-  actions: [
-    {
-      create_alias: {
-        collection_name: "example_collection",
-        alias_name: "production_collection",
-      },
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::CreateAliasBuilder;
-
-client
-    .create_alias(CreateAliasBuilder::new(
-        "example_collection",
-        "production_collection",
-    ))
-    .await?;
-```
-
-```java
-client.createAliasAsync("production_collection", "example_collection").get();
-```
-
-```csharp
-await client.CreateAliasAsync(aliasName: "production_collection", collectionName: "example_collection");
-```
-
-```go
-import "context"
-
-client.CreateAlias(context.Background(), "production_collection", "example_collection")
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-aliases/create/" >}}
 
 ### Remove alias
 
-```bash
-curl -X POST http://localhost:6333/collections/aliases \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "actions": [
-        {
-            "delete_alias": {
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}'
-```
-
-```http
-POST /collections/aliases
-{
-    "actions": [
-        {
-            "delete_alias": {
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}
-```
-
-```python
-client.update_collection_aliases(
-    change_aliases_operations=[
-        models.DeleteAliasOperation(
-            delete_alias=models.DeleteAlias(alias_name="production_collection")
-        ),
-    ]
-)
-```
-
-```typescript
-client.updateCollectionAliases({
-  actions: [
-    {
-      delete_alias: {
-        alias_name: "production_collection",
-      },
-    },
-  ],
-});
-```
-
-```rust
-client.delete_alias("production_collection").await?;
-```
-
-```java
-client.deleteAliasAsync("production_collection").get();
-```
-
-```csharp
-await client.DeleteAliasAsync("production_collection");
-```
-
-```go
-import "context"
-
-client.DeleteAlias(context.Background(), "production_collection")
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-aliases/delete/" >}}
 
 ### Switch collection
 
 Multiple alias actions are performed atomically.
 For example, you can switch underlying collection with the following command:
 
-```http
-POST /collections/aliases
-{
-    "actions": [
-        {
-            "delete_alias": {
-                "alias_name": "production_collection"
-            }
-        },
-        {
-            "create_alias": {
-                "collection_name": "example_collection",
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}
-```
-
-```bash
-curl -X POST http://localhost:6333/collections/aliases \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "actions": [
-        {
-            "delete_alias": {
-                "alias_name": "production_collection"
-            }
-        },
-        {
-            "create_alias": {
-                "collection_name": "example_collection",
-                "alias_name": "production_collection"
-            }
-        }
-    ]
-}'
-```
-
-```python
-client.update_collection_aliases(
-    change_aliases_operations=[
-        models.DeleteAliasOperation(
-            delete_alias=models.DeleteAlias(alias_name="production_collection")
-        ),
-        models.CreateAliasOperation(
-            create_alias=models.CreateAlias(
-                collection_name="example_collection", alias_name="production_collection"
-            )
-        ),
-    ]
-)
-```
-
-```typescript
-client.updateCollectionAliases({
-  actions: [
-    {
-      delete_alias: {
-        alias_name: "production_collection",
-      },
-    },
-    {
-      create_alias: {
-        collection_name: "example_collection",
-        alias_name: "production_collection",
-      },
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::CreateAliasBuilder;
-
-client.delete_alias("production_collection").await?;
-client
-    .create_alias(CreateAliasBuilder::new(
-        "example_collection",
-        "production_collection",
-    ))
-    .await?;
-```
-
-```java
-client.deleteAliasAsync("production_collection").get();
-client.createAliasAsync("production_collection", "example_collection").get();
-```
-
-```csharp
-await client.DeleteAliasAsync("production_collection");
-await client.CreateAliasAsync(aliasName: "production_collection", collectionName: "example_collection");
-```
-
-```go
-import "context"
-
-client.DeleteAlias(context.Background(), "production_collection")
-client.CreateAlias(context.Background(), "production_collection", "example_collection")
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-aliases/switch/" >}}
 
 ### List collection aliases
 
-```http
-GET /collections/{collection_name}/aliases
-```
-
-```bash
-curl -X GET http://localhost:6333/collections/{collection_name}/aliases
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.get_collection_aliases(collection_name="{collection_name}")
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.getCollectionAliases("{collection_name}");
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.list_collection_aliases("{collection_name}").await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.listCollectionAliasesAsync("{collection_name}").get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ListCollectionAliasesAsync("{collection_name}");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.ListCollectionAliases(context.Background(), "{collection_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-aliases/list/" >}}
 
 ### List all aliases
 
-```http
-GET /aliases
-```
-
-```bash
-curl -X GET http://localhost:6333/aliases
-```
-
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.get_aliases()
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.getAliases();
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.list_aliases().await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.listAliasesAsync().get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ListAliasesAsync();
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.ListAliases(context.Background())
-```
+{{< code-snippet path="/documentation/headless/snippets/collection-aliases/list-all/" >}}
 
 ### List all collections
 
-```http
-GET /collections
-```
-
-```bash
-curl -X GET http://localhost:6333/collections
-```
-
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.get_collections()
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.getCollections();
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.list_collections().await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.listCollectionsAsync().get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ListCollectionsAsync();
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.ListCollections(context.Background())
-```
+{{< code-snippet path="/documentation/headless/snippets/list-all-collections/simple/" >}}
diff --git a/qdrant-landing/content/documentation/concepts/explore.md b/qdrant-landing/content/documentation/concepts/explore.md
index 5a45ea125..98b273135 100644
--- a/qdrant-landing/content/documentation/concepts/explore.md
+++ b/qdrant-landing/content/documentation/concepts/explore.md
@@ -15,190 +15,7 @@ In addition to the regular search, Qdrant also allows you to search based on mul
 
 REST API - API Schema definition is available [here](https://api.qdrant.tech/api-reference/search/recommend-points)
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "recommend": {
-      "positive": [100, 231],
-      "negative": [718, [0.2, 0.3, 0.4, 0.5]],
-      "strategy": "average_vector"
-    }
-  },
-  "filter": {
-    "must": [
-      {
-        "key": "city",
-        "match": {
-          "value": "London"
-        }
-      }
-    ]
-  }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=models.RecommendQuery(
-        recommend=models.RecommendInput(
-            positive=[100, 231],
-            negative=[718, [0.2, 0.3, 0.4, 0.5]],
-            strategy=models.RecommendStrategy.AVERAGE_VECTOR,
-        )
-    ),
-    query_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="city",
-                match=models.MatchValue(
-                    value="London",
-                ),
-            )
-        ]
-    ),
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: {
-        recommend: {
-            positive: [100, 231],
-            negative: [718, [0.2, 0.3, 0.4, 0.5]],
-            strategy: "average_vector"
-        }
-    },
-    filter: {
-        must: [
-            {
-                key: "city",
-                match: {
-                    value: "London",
-                },
-            },
-        ],
-    },
-    limit: 3
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    Condition, Filter, QueryPointsBuilder, RecommendInputBuilder, RecommendStrategy,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-    
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(
-                RecommendInputBuilder::default()
-                    .add_positive(100)
-                    .add_positive(231)
-                    .add_positive(vec![0.2, 0.3, 0.4, 0.5])
-                    .add_negative(718)
-                    .strategy(RecommendStrategy::AverageVector)
-                    .build(),
-            )
-            .limit(3)
-            .filter(Filter::must([Condition::matches(
-                "city",
-                "London".to_string(),
-            )])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.RecommendInput;
-import io.qdrant.client.grpc.Points.RecommendStrategy;
-import io.qdrant.client.grpc.Points.Filter;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.recommend;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(recommend(RecommendInput.newBuilder()
-                .addAllPositive(List.of(vectorInput(100), vectorInput(200), vectorInput(100.0f, 231.0f)))
-                .addAllNegative(List.of(vectorInput(718), vectorInput(0.2f, 0.3f, 0.4f, 0.5f)))
-                .setStrategy(RecommendStrategy.AverageVector)
-                .build()))
-        .setFilter(Filter.newBuilder().addMust(matchKeyword("city", "London")))
-        .setLimit(3)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new RecommendInput {
-        Positive = { 100, 231 },
-        Negative = { 718 }
-    },
-    filter: MatchKeyword("city", "London"),
-    limit: 3
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-    CollectionName: "{collection_name}",
-    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
-        Positive: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
-        },
-        Negative: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-        },
-    }),
-    Filter: &qdrant.Filter{
-        Must: []*qdrant.Condition{
-            qdrant.NewMatch("city", "London"),
-        },
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/basic-recommend/" >}}
 
 Example result of this API would be
 
@@ -269,129 +86,7 @@ Combining negative-only examples with filtering can be a powerful tool for data
 
 If the collection was created with multiple vectors, the name of the vector should be specified in the recommendation request:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "recommend": {
-      "positive": [100, 231],
-      "negative": [718]
-    }
-  },
-  "using": "image",
-  "limit": 10
-}
-```
-
-```python
-client.query_points(
-    collection_name="{collection_name}",
-    query=models.RecommendQuery(
-        recommend=models.RecommendInput(
-            positive=[100, 231],
-            negative=[718],
-        )
-    ),
-    using="image",
-    limit=10,
-)
-```
-
-```typescript
-client.query("{collection_name}", {
-    query: {
-        recommend: {
-            positive: [100, 231],
-            negative: [718],
-        }
-    },
-    using: "image",
-    limit: 10
-});
-```
-
-```rust
-use qdrant_client::qdrant::{QueryPointsBuilder, RecommendInputBuilder};
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(
-                RecommendInputBuilder::default()
-                    .add_positive(100)
-                    .add_positive(231)
-                    .add_negative(718)
-                    .build(),
-            )
-            .limit(10)
-            .using("image"),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.RecommendInput;
-
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.recommend;
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(recommend(RecommendInput.newBuilder()
-                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
-                .addAllNegative(List.of(vectorInput(718)))
-                .build()))
-        .setUsing("image")
-        .setLimit(10)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new RecommendInput {
-        Positive = { 100, 231 },
-        Negative = { 718 }
-    },
-    usingVector: "image",
-    limit: 10
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-    CollectionName: "{collection_name}",
-    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
-        Positive: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
-        },
-        Negative: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-        },
-    }),
-    Using: qdrant.PtrOf("image"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/recommend-named-vectors/" >}}
 
 Parameter `using` specifies which stored vectors to use for the recommendation.
 
@@ -406,158 +101,7 @@ you can use the `lookup_from` parameter.
 It might be useful, e.g. in the item-to-user recommendations scenario. 
 Where user and item embeddings, although having the same vector parameters (distance type and dimensionality), are usually stored in different collections.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "recommend": {
-      "positive": [100, 231],
-      "negative": [718]
-    }
-  },
-  "limit": 10,
-  "lookup_from": {
-    "collection": "{external_collection_name}",
-    "vector": "{external_vector_name}"
-  }
-}
-```
-
-```python
-client.query_points(
-    collection_name="{collection_name}",
-    query=models.RecommendQuery(
-        recommend=models.RecommendInput(
-            positive=[100, 231],
-            negative=[718],
-        )
-    ),
-    using="image",
-    limit=10,
-    lookup_from=models.LookupLocation(
-        collection="{external_collection_name}", vector="{external_vector_name}"
-    ),
-)
-```
-
-```typescript
-client.query("{collection_name}", {
-    query: {
-        recommend: {
-            positive: [100, 231],
-            negative: [718],
-        }
-    },
-    using: "image",
-    limit: 10,
-    lookup_from: {
-        collection: "{external_collection_name}",
-        vector: "{external_vector_name}"
-    }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{LookupLocationBuilder, QueryPointsBuilder, RecommendInputBuilder};
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(
-                RecommendInputBuilder::default()
-                    .add_positive(100)
-                    .add_positive(231)
-                    .add_negative(718)
-                    .build(),
-            )
-            .limit(10)
-            .using("image")
-            .lookup_from(
-                LookupLocationBuilder::new("{external_collection_name}")
-                    .vector_name("{external_vector_name}"),
-            ),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.grpc.Points.LookupLocation;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.RecommendInput;
-
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.recommend;
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(recommend(RecommendInput.newBuilder()
-                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
-                .addAllNegative(List.of(vectorInput(718)))
-                .build()))
-        .setUsing("image")
-        .setLimit(10)
-        .setLookupFrom(
-                LookupLocation.newBuilder()
-                        .setCollectionName("{external_collection_name}")
-                        .setVectorName("{external_vector_name}")
-                        .build())
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new RecommendInput {
-        Positive = { 100, 231 },
-        Negative = { 718 }
-    },
-    usingVector: "image",
-    limit: 10,
-    lookupFrom: new LookupLocation
-    {
-        CollectionName = "{external_collection_name}",
-        VectorName = "{external_vector_name}",
-    }
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-    CollectionName: "{collection_name}",
-    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
-        Positive: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
-        },
-        Negative: []*qdrant.VectorInput{
-            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-        },
-    }),
-    Using: qdrant.PtrOf("image"),
-    LookupFrom: &qdrant.LookupLocation{
-        CollectionName: "{external_collection_name}",
-        VectorName:     qdrant.PtrOf("{external_vector_name}"),
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/recommend-lookup-from/" >}}
 
 Vectors are retrieved from the external collection by ids provided in the `positive` and `negative` lists. 
 These vectors then used to perform the recommendation in the current collection, comparing against the "using" or default vector.
@@ -569,308 +113,7 @@ These vectors then used to perform the recommendation in the current collection,
 
 Similar to the batch search API in terms of usage and advantages, it enables the batching of recommendation requests.
 
-```http
-POST /collections/{collection_name}/query/batch
-{
-  "searches": [
-    {
-      "query": {
-        "recommend": {
-          "positive": [100, 231],
-          "negative": [718]
-        }
-      },
-      "filter": {
-        "must": [
-          {
-            "key": "city",
-            "match": {
-              "value": "London"
-            }
-          }
-        ]
-      },
-      "limit": 10
-    },
-    {
-      "query": {
-        "recommend": {
-          "positive": [200, 67],
-          "negative": [300]
-        }
-      },
-      "filter": {
-        "must": [
-          {
-            "key": "city",
-            "match": {
-              "value": "London"
-            }
-          }
-        ]
-      },
-      "limit": 10
-    }
-  ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-filter_ = models.Filter(
-    must=[
-        models.FieldCondition(
-            key="city",
-            match=models.MatchValue(
-                value="London",
-            ),
-        )
-    ]
-)
-
-recommend_queries = [
-    models.QueryRequest(
-        query=models.RecommendQuery(
-            recommend=models.RecommendInput(positive=[100, 231], negative=[718])
-        ),
-        filter=filter_,
-        limit=3,
-    ),
-    models.QueryRequest(
-        query=models.RecommendQuery(
-            recommend=models.RecommendInput(positive=[200, 67], negative=[300])
-        ),
-        filter=filter_,
-        limit=3,
-    ),
-]
-
-client.query_batch_points(
-    collection_name="{collection_name}", requests=recommend_queries
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-const filter = {
-    must: [
-        {
-            key: "city",
-            match: {
-                value: "London",
-            },
-        },
-    ],
-};
-
-const searches = [
-    {
-        query: {
-            recommend: {
-                positive: [100, 231],
-                negative: [718]
-            }
-        },
-        filter,
-        limit: 3,
-    },
-    {
-        query: {
-            recommend: {
-                positive: [200, 67],
-                negative: [300]
-            }
-        },
-        filter,
-        limit: 3,
-    },
-];
-
-client.queryBatch("{collection_name}", {
-    searches,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    Condition, Filter, QueryBatchPointsBuilder, QueryPointsBuilder,
-    RecommendInputBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let filter = Filter::must([Condition::matches("city", "London".to_string())]);
-
-let recommend_queries = vec![
-    QueryPointsBuilder::new("{collection_name}")
-        .query(
-            RecommendInputBuilder::default()
-                .add_positive(100)
-                .add_positive(231)
-                .add_negative(718)
-                .build(),
-        )
-        .filter(filter.clone())
-        .build(),
-    QueryPointsBuilder::new("{collection_name}")
-        .query(
-            RecommendInputBuilder::default()
-                .add_positive(200)
-                .add_positive(67)
-                .add_negative(300)
-                .build(),
-        )
-        .filter(filter)
-        .build(),
-];
-
-client
-    .query_batch(QueryBatchPointsBuilder::new(
-        "{collection_name}",
-        recommend_queries,
-    ))
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.RecommendInput;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.recommend;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-Filter filter = Filter.newBuilder().addMust(matchKeyword("city", "London")).build();
-
-List<QueryPoints> recommendQueries = List.of(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(recommend(
-                        RecommendInput.newBuilder()
-                                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
-                                .addAllNegative(List.of(vectorInput(731)))
-                                .build()))
-                .setFilter(filter)
-                .setLimit(3)
-                .build(),
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(recommend(
-                        RecommendInput.newBuilder()
-                                .addAllPositive(List.of(vectorInput(200), vectorInput(67)))
-                                .addAllNegative(List.of(vectorInput(300)))
-                                .build()))
-                .setFilter(filter)
-                .setLimit(3)
-                .build());
-                
-client.queryBatchAsync("{collection_name}", recommendQueries).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-var filter = MatchKeyword("city", "london");
-
-await client.QueryBatchAsync(
-    collectionName: "{collection_name}",
-    queries:
-    [
-        new QueryPoints()
-        {
-            CollectionName = "{collection_name}",
-            Query = new RecommendInput {
-                Positive = { 100, 231 },
-                Negative = { 718 },
-            },
-            Limit = 3,
-            Filter = filter,
-        },
-                new QueryPoints()
-        {
-            CollectionName = "{collection_name}",
-            Query = new RecommendInput {
-                Positive = { 200, 67 },
-                Negative = { 300 },
-            },
-            Limit = 3,
-            Filter = filter,
-        }
-    ]
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-filter := qdrant.Filter{
-    Must: []*qdrant.Condition{
-        qdrant.NewMatch("city", "London"),
-    },
-}
-client.QueryBatch(context.Background(), &qdrant.QueryBatchPoints{
-    CollectionName: "{collection_name}",
-    QueryPoints: []*qdrant.QueryPoints{
-        {
-            CollectionName: "{collection_name}",
-            Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
-                Positive: []*qdrant.VectorInput{
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
-                },
-                Negative: []*qdrant.VectorInput{
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-                },
-            },
-            ),
-            Filter: &filter,
-        },
-        {
-            CollectionName: "{collection_name}",
-            Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
-                Positive: []*qdrant.VectorInput{
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(67)),
-                },
-                Negative: []*qdrant.VectorInput{
-                    qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
-                },
-            },
-            ),
-            Filter: &filter,
-        },
-    },
-},
-)
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/recommend-batch/" >}}
 
 The result of this API contains one array per recommendation requests.
 
@@ -933,197 +176,7 @@ where $s(v)$ is the similarity function, $v_t$ is the target vector, and again $
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "discover": {
-      "target": [0.2, 0.1, 0.9, 0.7],
-      "context": [
-        {
-          "positive": 100,
-          "negative": 718
-        },
-        {
-          "positive": 200,
-          "negative": 300
-        }
-      ]
-    }
-  },
-  "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-discover_queries = [
-    models.QueryRequest(
-        query=models.DiscoverQuery(
-            discover=models.DiscoverInput(
-                target=[0.2, 0.1, 0.9, 0.7],
-                context=[
-                    models.ContextPair(
-                        positive=100,
-                        negative=718,
-                    ),
-                    models.ContextPair(
-                        positive=200,
-                        negative=300,
-                    ),
-                ],
-            )
-        ),
-        limit=10,
-    ),
-]
-
-client.query_batch_points(
-    collection_name="{collection_name}", requests=discover_queries
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: {
-        discover: {
-            target: [0.2, 0.1, 0.9, 0.7],
-            context: [
-                {
-                    positive: 100,
-                    negative: 718,
-                },
-                {
-                    positive: 200,
-                    negative: 300,
-                },
-            ],
-        }
-    },
-    limit: 10,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{ContextInputBuilder, DiscoverInputBuilder, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}").query(
-            DiscoverInputBuilder::new(
-                vec![0.2, 0.1, 0.9, 0.7],
-                ContextInputBuilder::default()
-                    .add_pair(100, 718)
-                    .add_pair(200, 300),
-            )
-            .build(),
-        ),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.ContextInput;
-import io.qdrant.client.grpc.Points.ContextInputPair;
-import io.qdrant.client.grpc.Points.DiscoverInput;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.discover;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(discover(DiscoverInput.newBuilder()
-                .setTarget(vectorInput(0.2f, 0.1f, 0.9f, 0.7f))
-                .setContext(ContextInput.newBuilder()
-                        .addAllPairs(List.of(
-                                ContextInputPair.newBuilder()
-                                        .setPositive(vectorInput(100))
-                                        .setNegative(vectorInput(718))
-                                        .build(),
-                                ContextInputPair.newBuilder()
-                                        .setPositive(vectorInput(200))
-                                        .setNegative(vectorInput(300))
-                                        .build()))
-                        .build())
-                .build()))
-        .setLimit(10)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new DiscoverInput {
-        Target = new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-        Context = new ContextInput {
-            Pairs = {
-                new ContextInputPair {
-                    Positive = 100,
-                    Negative = 718
-                },
-                new ContextInputPair {
-                    Positive = 200,
-                    Negative = 300
-                },
-            }   
-        },
-    },
-    limit: 10
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-    CollectionName: "{collection_name}",
-    Query: qdrant.NewQueryDiscover(&qdrant.DiscoverInput{
-        Target: qdrant.NewVectorInput(0.2, 0.1, 0.9, 0.7),
-        Context: &qdrant.ContextInput{
-            Pairs: []*qdrant.ContextInputPair{
-                {
-                    Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-                    Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-                },
-                {
-                    Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
-                    Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
-                },
-            },
-        },
-    }),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/discovery-basic/" >}}
 
 <aside role="status">
 Notes about discovery search:
@@ -1152,177 +205,7 @@ Using this kind of search, you can expect the output to not necessarily be aroun
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "context": [
-      {
-        "positive": 100,
-        "negative": 718
-      },
-      {
-        "positive": 200,
-        "negative": 300
-      }
-    ]
-  },
-  "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-discover_queries = [
-    models.QueryRequest(
-        query=models.ContextQuery(
-            context=[
-                models.ContextPair(
-                    positive=100,
-                    negative=718,
-                ),
-                models.ContextPair(
-                    positive=200,
-                    negative=300,
-                ),
-            ],
-        ),
-        limit=10,
-    ),
-]
-
-client.query_batch_points(
-    collection_name="{collection_name}", requests=discover_queries
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: {
-        context: [
-            {
-                positive: 100,
-                negative: 718,
-            },
-            {
-                positive: 200,
-                negative: 300,
-            },
-        ]
-    },
-    limit: 10,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{ContextInputBuilder, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}").query(
-            ContextInputBuilder::default()
-                .add_pair(100, 718)
-                .add_pair(200, 300)
-                .build(),
-        ),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.ContextInput;
-import io.qdrant.client.grpc.Points.ContextInputPair;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.VectorInputFactory.vectorInput;
-import static io.qdrant.client.QueryFactory.context;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(context(ContextInput.newBuilder()
-                .addAllPairs(List.of(
-                        ContextInputPair.newBuilder()
-                                .setPositive(vectorInput(100))
-                                .setNegative(vectorInput(718))
-                                .build(),
-                        ContextInputPair.newBuilder()
-                                .setPositive(vectorInput(200))
-                                .setNegative(vectorInput(300))
-                                .build()))
-                .build()))
-        .setLimit(10)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  query: new ContextInput {
-    Pairs = {
-      new ContextInputPair {
-        Positive = 100,
-          Negative = 718
-      },
-      new ContextInputPair {
-        Positive = 200,
-          Negative = 300
-      },
-    }
-  },
-  limit: 10
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-    CollectionName: "{collection_name}",
-    Query: qdrant.NewQueryContext(&qdrant.ContextInput{
-        Pairs: []*qdrant.ContextInputPair{
-            {
-                Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
-                Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
-            },
-            {
-                Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
-                Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
-            },
-        },
-    }),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points-explore/context-basic/" >}}
 
 <aside role="status">
 Notes about context search:
@@ -1358,139 +241,7 @@ The distance matrix API offers two output formats to ease the integration with d
 
 Returns the distance matrix as a list of pairs of point `ids` with their respective score.
 
-```http
-POST /collections/{collection_name}/points/search/matrix/pairs
-{
-    "sample": 10,
-    "limit": 2,
-    "filter": {
-        "must": {
-            "key": "color",
-            "match": { "value": "red" }
-        }
-    }  
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.search_matrix_pairs(
-    collection_name="{collection_name}",
-    sample=10,
-    limit=2,
-    query_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="color", match=models.MatchValue(value="red")
-            ),
-        ]
-    ),
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.SearchMatrixPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .searchMatrixPairsAsync(
-        Points.SearchMatrixPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-            .setSample(10)
-            .setLimit(2)
-            .build())
-    .get();
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, SearchMatrixPointsBuilder};
-use qdrant_client::Qdrant;
-
-client
-    .search_matrix_pairs(
-        SearchMatrixPointsBuilder::new("collection_name")
-           .filter(Filter::must(vec![Condition::matches(
-               "color",
-               "red".to_string(),
-           )]))
-           .sample(10)
-           .limit(2),
-    )
-    .await?;
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.searchMatrixPairs("{collection_name}", {
-    filter: {
-        must: [
-            {
-                key: "color",
-                match: {
-                    value: "red",
-                },
-            },
-        ],
-    },
-    sample: 10,
-    limit: 2,
-});
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.SearchMatrixPairsAsync(
-    collectionName: "{collection_name}",
-    filter: MatchKeyword("color", "red"),
-    sample: 10,
-    limit: 2
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-sample := uint64(10)
-limit := uint64(2)
-res, err := client.SearchMatrixPairs(ctx, &qdrant.SearchMatrixPoints{
-    CollectionName: "{collection_name}",
-    Sample:         &sample,
-    Limit:          &limit,
-    Filter: &qdrant.Filter{
-        Must: []*qdrant.Condition{
-            qdrant.NewMatch("color", "red"),
-        },
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/distance-matrix/basic/" >}}
 
 Returns
 
@@ -1526,139 +277,7 @@ Returns the distance matrix as a four arrays:
 - `scores` contains the distance values.
 - `ids` contains the point ids corresponding to the distance values.
 
-```http
-POST /collections/{collection_name}/points/search/matrix/offsets
-{
-    "sample": 10,
-    "limit": 2,
-    "filter": {
-        "must": {
-            "key": "color",
-            "match": { "value": "red" }
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.search_matrix_offsets(
-    collection_name="{collection_name}",
-    sample=10,
-    limit=2,
-    query_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="color", match=models.MatchValue(value="red")
-            ),
-        ]
-    ),
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.SearchMatrixPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .searchMatrixOffsetsAsync(
-        SearchMatrixPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-            .setSample(10)
-            .setLimit(2)
-            .build())
-    .get();
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, SearchMatrixPointsBuilder};
-use qdrant_client::Qdrant;
-
-client
-    .search_matrix_offsets(
-        SearchMatrixPointsBuilder::new("collection_name")
-           .filter(Filter::must(vec![Condition::matches(
-               "color",
-               "red".to_string(),
-           )]))
-           .sample(10)
-           .limit(2),
-    )
-    .await?;
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.searchMatrixOffsets("{collection_name}", {
-    filter: {
-        must: [
-            {
-                key: "color",
-                match: {
-                    value: "red",
-                },
-            },
-        ],
-    },
-    sample: 10,
-    limit: 2,
-});
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.SearchMatrixOffsetsAsync(
-    collectionName: "{collection_name}",
-    filter: MatchKeyword("color", "red"),
-    sample: 10,
-    limit: 2
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-sample := uint64(10)
-limit := uint64(2)
-res, err := client.SearchMatrixOffsets(ctx, &qdrant.SearchMatrixPoints{
-    CollectionName: "{collection_name}",
-    Sample:         &sample,
-    Limit:          &limit,
-    Filter: &qdrant.Filter{
-        Must: []*qdrant.Condition{
-            qdrant.NewMatch("color", "red"),
-        },
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/distance-matrix/offsets-format/" >}}
 
 Returns
 
diff --git a/qdrant-landing/content/documentation/concepts/filtering.md b/qdrant-landing/content/documentation/concepts/filtering.md
index 3c73b0489..d05d808c2 100644
--- a/qdrant-landing/content/documentation/concepts/filtering.md
+++ b/qdrant-landing/content/documentation/concepts/filtering.md
@@ -42,139 +42,7 @@ Suppose we have a set of points with the following payload:
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            { "key": "city", "match": { "value": "London" } },
-            { "key": "color", "match": { "value": "red" } }
-        ]
-    }
-    ...
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="city",
-                match=models.MatchValue(value="London"),
-            ),
-            models.FieldCondition(
-                key="color",
-                match=models.MatchValue(value="red"),
-            ),
-        ]
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "city",
-        match: { value: "London" },
-      },
-      {
-        key: "color",
-        match: { value: "red" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
-            Condition::matches("city", "london".to_string()),
-            Condition::matches("color", "red".to_string()),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addAllMust(
-                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-// & operator combines two conditions in an AND conjunction(must)
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("city", "London") & MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("city", "London"),
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-must-filter/" >}}
 
 Filtered points would be:
 
@@ -189,124 +57,7 @@ In this sense, `must` is equivalent to the operator `AND`.
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "should": [
-            { "key": "city", "match": { "value": "London" } },
-            { "key": "color", "match": { "value": "red" } }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        should=[
-            models.FieldCondition(
-                key="city",
-                match=models.MatchValue(value="London"),
-            ),
-            models.FieldCondition(
-                key="color",
-                match=models.MatchValue(value="red"),
-            ),
-        ]
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    should: [
-      {
-        key: "city",
-        match: { value: "London" },
-      },
-      {
-        key: "color",
-        match: { value: "red" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
-            Condition::matches("city", "london".to_string()),
-            Condition::matches("color", "red".to_string()),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-import java.util.List;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addAllShould(
-                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-// | operator combines two conditions in an OR disjunction(should)
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("city", "London") | MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Should: []*qdrant.Condition{
-			qdrant.NewMatch("city", "London"),
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-should-filter/" >}}
 
 Filtered points would be:
 
@@ -326,119 +77,7 @@ In this sense, `should` is equivalent to the operator `OR`.
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must_not": [
-            { "key": "city", "match": { "value": "London" } },
-            { "key": "color", "match": { "value": "red" } }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must_not=[
-            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
-            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
-        ]
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must_not: [
-      {
-        key: "city",
-        match: { value: "London" },
-      },
-      {
-        key: "color",
-        match: { value: "red" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([
-            Condition::matches("city", "london".to_string()),
-            Condition::matches("color", "red".to_string()),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addAllMustNot(
-                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-// The ! operator negates the condition(must not)
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: !(MatchKeyword("city", "London") & MatchKeyword("color", "red"))
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		MustNot: []*qdrant.Condition{
-			qdrant.NewMatch("city", "London"),
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-must-not-filter/" >}}
 
 Filtered points would be:
 
@@ -456,122 +95,7 @@ In this sense, `must_not` is equivalent to the expression `(NOT A) AND (NOT B) A
 
 It is also possible to use several clauses simultaneously:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            { "key": "city", "match": { "value": "London" } }
-        ],
-        "must_not": [
-            { "key": "color", "match": { "value": "red" } }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
-        ],
-        must_not=[
-            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "city",
-        match: { value: "London" },
-      },
-    ],
-    must_not: [
-      {
-        key: "color",
-        match: { value: "red" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter {
-            must: vec![Condition::matches("city", "London".to_string())],
-            must_not: vec![Condition::matches("color", "red".to_string())],
-            ..Default::default()
-        }),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMust(matchKeyword("city", "London"))
-                    .addMustNot(matchKeyword("color", "red"))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("city", "London") & !MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("city", "London"),
-		},
-		MustNot: []*qdrant.Condition{
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/" >}}
 
 Filtered points would be:
 
@@ -586,146 +110,7 @@ In this case, the conditions are combined by `AND`.
 
 Also, the conditions could be recursively nested. Example:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must_not": [
-            {
-                "must": [
-                    { "key": "city", "match": { "value": "London" } },
-                    { "key": "color", "match": { "value": "red" } }
-                ]
-            }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must_not=[
-            models.Filter(
-                must=[
-                    models.FieldCondition(
-                        key="city", match=models.MatchValue(value="London")
-                    ),
-                    models.FieldCondition(
-                        key="color", match=models.MatchValue(value="red")
-                    ),
-                ],
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must_not: [
-      {
-        must: [
-          {
-            key: "city",
-            match: { value: "London" },
-          },
-          {
-            key: "color",
-            match: { value: "red" },
-          },
-        ],
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([Filter::must(
-            [
-                Condition::matches("city", "London".to_string()),
-                Condition::matches("color", "red".to_string()),
-            ],
-        )
-        .into()])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.filter;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMustNot(
-                        filter(
-                            Filter.newBuilder()
-                                .addAllMust(
-                                    List.of(
-                                        matchKeyword("city", "London"),
-                                        matchKeyword("color", "red")))
-                                .build()))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: new Filter { MustNot = { MatchKeyword("city", "London") & MatchKeyword("color", "red") } }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		MustNot: []*qdrant.Condition{
-			qdrant.NewFilterAsCondition(&qdrant.Filter{
-				Must: []*qdrant.Condition{
-					qdrant.NewMatch("city", "London"),
-					qdrant.NewMatch("color", "red"),
-				},
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/" >}}
 
 Filtered points would be:
 
@@ -746,95 +131,11 @@ Let's look at the existing condition variants and what types of data they apply
 
 ### Match
 
-```json
-{
-  "key": "color",
-  "match": {
-    "value": "red"
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="color",
-    match=models.MatchValue(value="red"),
-)
-```
-
-```typescript
-{
-    key: 'color', 
-    match: {value: 'red'}
-}
-```
-
-```rust
-Condition::matches("color", "red".to_string())
-```
-
-```java
-matchKeyword("color", "red");
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-MatchKeyword("color", "red");
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatch("color", "red")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/match-keyword/" >}}
 
 For the other types, the match condition will look exactly the same, except for the type used:
 
-```json
-{
-  "key": "count",
-  "match": {
-    "value": 0
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="count",
-    match=models.MatchValue(value=0),
-)
-```
-
-```typescript
-{
-    key: 'count',
-    match: {value: 0}    
-}
-```
-
-```rust
-Condition::matches("count", 0)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.match;
-
-match("count", 0);
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-Match("count", 0);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatchInt("count", 0)
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/match-integer/" >}}
 
 The simplest kind of condition is one that checks if the stored value equals the given one.
 If several values are stored, at least one of them should match the condition.
@@ -851,50 +152,7 @@ You can apply it to [keyword](/documentation/concepts/payload/#keyword) and [int
 
 Example:
 
-```json
-{
-  "key": "color",
-  "match": {
-    "any": ["black", "yellow"]
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="color",
-    match=models.MatchAny(any=["black", "yellow"]),
-)
-```
-
-```typescript
-{
-    key: 'color',
-    match: {any: ['black', 'yellow']}    
-}
-```
-
-```rust
-Condition::matches("color", vec!["black".to_string(), "yellow".to_string()])
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeywords;
-
-matchKeywords("color", List.of("black", "yellow"));
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-Match("color", ["black", "yellow"]);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatchKeywords("color", "black", "yellow")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/match-any/" >}}
 
 In this example, the condition will be satisfied if the stored value is either `black` or `yellow`.
 
@@ -913,55 +171,7 @@ You can apply it to [keyword](/documentation/concepts/payload/#keyword) and [int
 
 Example:
 
-```json
-{
-  "key": "color",
-  "match": {
-    "except": ["black", "yellow"]
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="color",
-    match=models.MatchExcept(**{"except": ["black", "yellow"]}),
-)
-```
-
-```typescript
-{
-    key: 'color',
-    match: {except: ['black', 'yellow']}
-}
-```
-
-```rust
-use qdrant_client::qdrant::r#match::MatchValue;
-
-Condition::matches(
-    "color",
-    !MatchValue::from(vec!["black".to_string(), "yellow".to_string()]),
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchExceptKeywords;
-
-matchExceptKeywords("color", List.of("black", "yellow"));
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-Match("color", ["black", "yellow"]);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatchExcept("color", "black", "yellow")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/match-except/" >}}
 
 In this example, the condition will be satisfied if the stored value is neither `black` nor `yellow`.
 
@@ -1020,351 +230,17 @@ Suppose we have a set of points with the following payload:
 
 You can search on a nested field using a dot notation.
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "should": [
-            {
-                "key": "country.name",
-                "match": {
-                    "value": "Germany"
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        should=[
-            models.FieldCondition(
-                key="country.name", match=models.MatchValue(value="Germany")
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    should: [
-      {
-        key: "country.name",
-        match: { value: "Germany" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
-            Condition::matches("country.name", "Germany".to_string()),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addShould(matchKeyword("country.name", "Germany"))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(collectionName: "{collection_name}", filter: MatchKeyword("country.name", "Germany"));
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Should: []*qdrant.Condition{
-			qdrant.NewMatch("country.name", "Germany"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/" >}}
 
 You can also search through arrays by projecting inner values using the `[]` syntax.
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "should": [
-            {
-                "key": "country.cities[].population",
-                "range": {
-                    "gte": 9.0,
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        should=[
-            models.FieldCondition(
-                key="country.cities[].population",
-                range=models.Range(
-                    gt=None,
-                    gte=9.0,
-                    lt=None,
-                    lte=None,
-                ),
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    should: [
-      {
-        key: "country.cities[].population",
-        range: {
-          gt: null,
-          gte: 9.0,
-          lt: null,
-          lte: null,
-        },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, Range, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
-            Condition::range(
-                "country.cities[].population",
-                Range {
-                    gte: Some(9.0),
-                    ..Default::default()
-                },
-            ),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.range;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.Range;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addShould(
-                        range(
-                            "country.cities[].population",
-                            Range.newBuilder().setGte(9.0).build()))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: Range("country.cities[].population", new Qdrant.Client.Grpc.Range { Gte = 9.0 })
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Should: []*qdrant.Condition{
-			qdrant.NewRange("country.cities[].population", &qdrant.Range{
-				Gte: qdrant.PtrOf(9.0),
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/" >}}
 
 This query would only output the point with id 2 as only Japan has a city with population greater than 9.0.
 
 And the leaf nested field can also be an array.
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "should": [
-            {
-                "key": "country.cities[].sightseeing",
-                "match": {
-                    "value": "Osaka Castle"
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        should=[
-            models.FieldCondition(
-                key="country.cities[].sightseeing",
-                match=models.MatchValue(value="Osaka Castle"),
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    should: [
-      {
-        key: "country.cities[].sightseeing",
-        match: { value: "Osaka Castle" },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
-            Condition::matches("country.cities[].sightseeing", "Osaka Castle".to_string()),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addShould(matchKeyword("country.cities[].sightseeing", "Germany"))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("country.cities[].sightseeing", "Germany")
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Should: []*qdrant.Condition{
-			qdrant.NewMatch("country.cities[].sightseeing", "Germany"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/" >}}
 
 This query would only output the point with id 2 as only Japan has a city with the "Osaka castke" as part of the sightseeing.
 
@@ -1399,135 +275,7 @@ For instance, given two points with the following payload:
 
 The following query would match both points:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            {
-                "key": "diet[].food",
-                  "match": {
-                    "value": "meat"
-                }
-            },
-            {
-                "key": "diet[].likes",
-                  "match": {
-                    "value": true
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="diet[].food", match=models.MatchValue(value="meat")
-            ),
-            models.FieldCondition(
-                key="diet[].likes", match=models.MatchValue(value=True)
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "diet[].food",
-        match: { value: "meat" },
-      },
-      {
-        key: "diet[].likes",
-        match: { value: true },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
-            Condition::matches("diet[].food", "meat".to_string()),
-            Condition::matches("diet[].likes", true),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.match;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addAllMust(
-                        List.of(matchKeyword("diet[].food", "meat"), match("diet[].likes", true)))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("diet[].food", "meat") & Match("diet[].likes", true)
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("diet[].food", "meat"),
-			qdrant.NewMatchBool("diet[].likes", true),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/" >}}
 
 This happens because both points are matching the two conditions:
 
@@ -1542,170 +290,7 @@ It is achieved by using the `nested` condition type formed by a payload key to f
 
 The key should point to an array of objects and can be used with or without the bracket notation ("data" or "data[]").
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [{
-            "nested": {
-                "key": "diet",
-                "filter":{
-                    "must": [
-                        {
-                            "key": "food",
-                            "match": {
-                                "value": "meat"
-                            }
-                        },
-                        {
-                            "key": "likes",
-                            "match": {
-                                "value": true
-                            }
-                        }
-                    ]
-                }
-            }
-        }]
-    }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.NestedCondition(
-                nested=models.Nested(
-                    key="diet",
-                    filter=models.Filter(
-                        must=[
-                            models.FieldCondition(
-                                key="food", match=models.MatchValue(value="meat")
-                            ),
-                            models.FieldCondition(
-                                key="likes", match=models.MatchValue(value=True)
-                            ),
-                        ]
-                    ),
-                )
-            )
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        nested: {
-          key: "diet",
-          filter: {
-            must: [
-              {
-                key: "food",
-                match: { value: "meat" },
-              },
-              {
-                key: "likes",
-                match: { value: true },
-              },
-            ],
-          },
-        },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([NestedCondition {
-            key: "diet".to_string(),
-            filter: Some(Filter::must([
-                Condition::matches("food", "meat".to_string()),
-                Condition::matches("likes", true),
-            ])),
-        }
-        .into()])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.match;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.ConditionFactory.nested;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMust(
-                        nested(
-                            "diet",
-                            Filter.newBuilder()
-                                .addAllMust(
-                                    List.of(
-                                        matchKeyword("food", "meat"), match("likes", true)))
-                                .build()))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true))
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewNestedFilter("diet", &qdrant.Filter{
-				Must: []*qdrant.Condition{
-					qdrant.NewMatch("food", "meat"),
-					qdrant.NewMatchBool("likes", true),
-				},
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/" >}}
 
 The matching logic is modified to be applied at the level of an array element within the payload.
 
@@ -1716,189 +301,7 @@ Parent document is considered to match the condition if at least one element of
 
 The `has_id` condition is not supported within the nested object filter. If you need it, place it in an adjacent `must` clause.
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-   "filter":{
-      "must":[
-         {
-            "nested":{
-               "key":"diet",
-               "filter":{
-                  "must":[
-                     {
-                        "key":"food",
-                        "match":{
-                           "value":"meat"
-                        }
-                     },
-                     {
-                        "key":"likes",
-                        "match":{
-                           "value":true
-                        }
-                     }
-                  ]
-               }
-            }
-         },
-         {
-            "has_id":[
-               1
-            ]
-         }
-      ]
-   }
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.NestedCondition(
-                nested=models.Nested(
-                    key="diet",
-                    filter=models.Filter(
-                        must=[
-                            models.FieldCondition(
-                                key="food", match=models.MatchValue(value="meat")
-                            ),
-                            models.FieldCondition(
-                                key="likes", match=models.MatchValue(value=True)
-                            ),
-                        ]
-                    ),
-                )
-            ),
-            models.HasIdCondition(has_id=[1]),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        nested: {
-          key: "diet",
-          filter: {
-            must: [
-              {
-                key: "food",
-                match: { value: "meat" },
-              },
-              {
-                key: "likes",
-                match: { value: true },
-              },
-            ],
-          },
-        },
-      },
-      {
-        has_id: [1],
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
-            NestedCondition {
-                key: "diet".to_string(),
-                filter: Some(Filter::must([
-                    Condition::matches("food", "meat".to_string()),
-                    Condition::matches("likes", true),
-                ])),
-            }
-            .into(),
-            Condition::has_id([1]),
-        ])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.hasId;
-import static io.qdrant.client.ConditionFactory.match;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.ConditionFactory.nested;
-import static io.qdrant.client.PointIdFactory.id;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMust(
-                        nested(
-                            "diet",
-                            Filter.newBuilder()
-                                .addAllMust(
-                                    List.of(
-                                        matchKeyword("food", "meat"), match("likes", true)))
-                                .build()))
-                    .addMust(hasId(id(1)))
-                    .build())
-            .build())
-    .get();
-```
-
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true)) & HasId(1)
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewNestedFilter("diet", &qdrant.Filter{
-				Must: []*qdrant.Condition{
-					qdrant.NewMatch("food", "meat"),
-					qdrant.NewMatchBool("likes", true),
-				},
-			}),
-			qdrant.NewHasID(qdrant.NewIDNum(1)),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/" >}}
 
 ### Full Text Match
 
@@ -1912,130 +315,13 @@ Configuration is defined during the index creation and describe at [full-text in
 
 If there is no full-text index for the field, the condition will work as exact substring match.
 
-```json
-{
-  "key": "description",
-  "match": {
-    "text": "good cheap"
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="description",
-    match=models.MatchText(text="good cheap"),
-)
-```
-
-```typescript
-{
-    key: 'description',
-    match: {text: 'good cheap'}    
-}
-```
-
-```rust
-use qdrant_client::qdrant::Condition;
-
-Condition::matches_text("description", "good cheap")
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchText;
-
-matchText("description", "good cheap");
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-MatchText("description", "good cheap");
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatchText("description", "good cheap")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/full-text-match/" >}}
 
 If the query has several words, then the condition will be satisfied only if all of them are present in the text.
 
 ### Range
 
-```json
-{
-  "key": "price",
-  "range": {
-    "gt": null,
-    "gte": 100.0,
-    "lt": null,
-    "lte": 450.0
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="price",
-    range=models.Range(
-        gt=None,
-        gte=100.0,
-        lt=None,
-        lte=450.0,
-    ),
-)
-```
-
-```typescript
-{
-    key: 'price',
-    range: {
-        gt: null,
-        gte: 100.0,
-        lt: null,
-        lte: 450.0    
-    }    
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Range};
-
-Condition::range(
-    "price",
-    Range {
-        gt: None,
-        gte: Some(100.0),
-        lt: None,
-        lte: Some(450.0),
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.range;
-
-import io.qdrant.client.grpc.Points.Range;
-
-range("price", Range.newBuilder().setGte(100.0).setLte(450).build());
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-Range("price", new Qdrant.Client.Grpc.Range { Gte = 100.0, Lte = 450 });
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewRange("price", &qdrant.Range{
-	Gte: qdrant.PtrOf(100.0),
-	Lte: qdrant.PtrOf(450.0),
-})
-
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/range/" >}}
 
 The `range` condition sets the range of possible values for stored payload values.
 If several values are stored, at least one of them should match the condition.
@@ -2056,96 +342,7 @@ You do not need to convert dates to UNIX timestaps. During comparison, timestamp
 
 _Available as of v1.8.0_
 
-```json
-{
-  "key": "date",
-  "range": {
-    "gt": "2023-02-08T10:49:00Z",
-    "gte": null,
-    "lt": null,
-    "lte": "2024-01-31 10:14:31Z"
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="date",
-    range=models.DatetimeRange(
-        gt="2023-02-08T10:49:00Z",
-        gte=None,
-        lt=None,
-        lte="2024-01-31T10:14:31Z",
-    ),
-)
-```
-
-```typescript
-{
-    key: 'date',
-    range: {
-        gt: '2023-02-08T10:49:00Z',
-        gte: null,
-        lt: null,
-        lte: '2024-01-31T10:14:31Z'
-    }
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, DatetimeRange, Timestamp};
-
-Condition::datetime_range(
-    "date",
-    DatetimeRange {
-        gt: Some(Timestamp::date_time(2023, 2, 8, 10, 49, 0).unwrap()),
-        gte: None,
-        lt: None,
-        lte: Some(Timestamp::date_time(2024, 1, 31, 10, 14, 31).unwrap()),
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.datetimeRange;
-
-import com.google.protobuf.Timestamp;
-import io.qdrant.client.grpc.Points.DatetimeRange;
-import java.time.Instant;
-
-long gt = Instant.parse("2023-02-08T10:49:00Z").getEpochSecond();
-long lte = Instant.parse("2024-01-31T10:14:31Z").getEpochSecond();
-
-datetimeRange("date",
-    DatetimeRange.newBuilder()
-        .setGt(Timestamp.newBuilder().setSeconds(gt))
-        .setLte(Timestamp.newBuilder().setSeconds(lte))
-        .build());
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-
-Conditions.DatetimeRange(
-    field: "date",
-    gt: new DateTime(2023, 2, 8, 10, 49, 0, DateTimeKind.Utc),
-    lte: new DateTime(2024, 1, 31, 10, 14, 31, DateTimeKind.Utc)
-);
-```
-
-```go
-import (
-	"time"
-
-	"github.com/qdrant/go-client/qdrant"
-	"google.golang.org/protobuf/types/known/timestamppb"
-)
-
-qdrant.NewDatetimeRange("date", &qdrant.DatetimeRange{
-	Gt:  timestamppb.New(time.Date(2023, 2, 8, 10, 49, 0, 0, time.UTC)),
-	Lte: timestamppb.New(time.Date(2024, 1, 31, 10, 14, 31, 0, time.UTC)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/datetime-range/" >}}
 
 ### UUID Match
 
@@ -2154,212 +351,19 @@ _Available as of v1.11.0_
 Matching of UUID values works similarly to the regular `match` condition for strings.
 Functionally, it will work with `keyword` and `uuid` indexes exactly the same, but `uuid` index is more memory efficient.
 
-```json
-{
-  "key": "uuid",
-  "match": {
-    "value": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="uuid",
-    match=models.MatchValue(value="f47ac10b-58cc-4372-a567-0e02b2c3d479"),
-)
-```
-
-```typescript
-{
-    key: 'uuid',
-    match: {value: 'f47ac10b-58cc-4372-a567-0e02b2c3d479'}    
-}
-```
-
-```rust
-Condition::matches("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479".to_string())
-```
-
-```java
-matchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-MatchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewMatch("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/match-uuid/" >}}
 
 ### Geo
 
 #### Geo Bounding Box
 
-```json
-{
-  "key": "location",
-  "geo_bounding_box": {
-    "bottom_right": {
-      "lon": 13.455868,
-      "lat": 52.495862
-    },
-    "top_left": {
-      "lon": 13.403683,
-      "lat": 52.520711
-    }
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="location",
-    geo_bounding_box=models.GeoBoundingBox(
-        bottom_right=models.GeoPoint(
-            lon=13.455868,
-            lat=52.495862,
-        ),
-        top_left=models.GeoPoint(
-            lon=13.403683,
-            lat=52.520711,
-        ),
-    ),
-)
-```
-
-```typescript
-{
-    key: 'location',
-    geo_bounding_box: {
-        bottom_right: {
-            lon: 13.455868,
-            lat: 52.495862
-        },
-        top_left: {
-            lon: 13.403683,
-            lat: 52.520711
-        }
-    }
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, GeoBoundingBox, GeoPoint};
-
-Condition::geo_bounding_box(
-    "location",
-    GeoBoundingBox {
-        bottom_right: Some(GeoPoint {
-            lon: 13.455868,
-            lat: 52.495862,
-        }),
-        top_left: Some(GeoPoint {
-            lon: 13.403683,
-            lat: 52.520711,
-        }),
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.geoBoundingBox;
-
-geoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-GeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewGeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868)
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/geo-bounding-box/" >}}
 
 It matches with `location`s inside a rectangle with the coordinates of the upper left corner in `bottom_right` and the coordinates of the lower right corner in `top_left`.
 
 #### Geo Radius
 
-```json
-{
-  "key": "location",
-  "geo_radius": {
-    "center": {
-      "lon": 13.403683,
-      "lat": 52.520711
-    },
-    "radius": 1000.0
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="location",
-    geo_radius=models.GeoRadius(
-        center=models.GeoPoint(
-            lon=13.403683,
-            lat=52.520711,
-        ),
-        radius=1000.0,
-    ),
-)
-```
-
-```typescript
-{
-    key: 'location',
-    geo_radius: {
-        center: {
-            lon: 13.403683,
-            lat: 52.520711
-        },
-        radius: 1000.0
-    }    
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, GeoPoint, GeoRadius};
-
-Condition::geo_radius(
-    "location",
-    GeoRadius {
-        center: Some(GeoPoint {
-            lon: 13.403683,
-            lat: 52.520711,
-        }),
-        radius: 1000.0,
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.geoRadius;
-
-geoRadius("location", 52.520711, 13.403683, 1000.0f);
-```
-
-```csharp
-using static Qdrant.Client.Grpc.Conditions;
-
-GeoRadius("location", 52.520711, 13.403683, 1000.0f);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewGeoRadius("location", 52.520711, 13.403683, 1000.0)
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/geo-radius/" >}}
 
 It matches with `location`s inside a circle with the `center` at the center and a radius of `radius` meters.
 
@@ -2373,290 +377,7 @@ When defining a ring, you must pick either a clockwise or counterclockwise order
 
 Currently, we only support unprojected global coordinates (decimal degrees longitude and latitude) and we are datum agnostic.
 
-```json
-
-{
-  "key": "location",
-  "geo_polygon": {
-    "exterior": {
-      "points": [
-        { "lon": -70.0, "lat": -70.0 },
-        { "lon": 60.0, "lat": -70.0 },
-        { "lon": 60.0, "lat": 60.0 },
-        { "lon": -70.0, "lat": 60.0 },
-        { "lon": -70.0, "lat": -70.0 }
-      ]
-    },
-    "interiors": [
-      {
-        "points": [
-          { "lon": -65.0, "lat": -65.0 },
-          { "lon": 0.0, "lat": -65.0 },
-          { "lon": 0.0, "lat": 0.0 },
-          { "lon": -65.0, "lat": 0.0 },
-          { "lon": -65.0, "lat": -65.0 }
-        ]
-      }
-    ]
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="location",
-    geo_polygon=models.GeoPolygon(
-        exterior=models.GeoLineString(
-            points=[
-                models.GeoPoint(
-                    lon=-70.0,
-                    lat=-70.0,
-                ),
-                models.GeoPoint(
-                    lon=60.0,
-                    lat=-70.0,
-                ),
-                models.GeoPoint(
-                    lon=60.0,
-                    lat=60.0,
-                ),
-                models.GeoPoint(
-                    lon=-70.0,
-                    lat=60.0,
-                ),
-                models.GeoPoint(
-                    lon=-70.0,
-                    lat=-70.0,
-                ),
-            ]
-        ),
-        interiors=[
-            models.GeoLineString(
-                points=[
-                    models.GeoPoint(
-                        lon=-65.0,
-                        lat=-65.0,
-                    ),
-                    models.GeoPoint(
-                        lon=0.0,
-                        lat=-65.0,
-                    ),
-                    models.GeoPoint(
-                        lon=0.0,
-                        lat=0.0,
-                    ),
-                    models.GeoPoint(
-                        lon=-65.0,
-                        lat=0.0,
-                    ),
-                    models.GeoPoint(
-                        lon=-65.0,
-                        lat=-65.0,
-                    ),
-                ]
-            )
-        ],
-    ),
-)
-```
-
-```typescript
-{
-  key: "location",
-  geo_polygon: {
-    exterior: {
-      points: [
-        {
-          lon: -70.0,
-          lat: -70.0
-        },
-        {
-          lon: 60.0,
-          lat: -70.0
-        },
-        {
-          lon: 60.0,
-          lat: 60.0
-        },
-        {
-          lon: -70.0,
-          lat: 60.0
-        },
-        {
-          lon: -70.0,
-          lat: -70.0
-        }
-      ]
-    },
-    interiors: [
-      {
-        points: [
-          {
-            lon: -65.0,
-            lat: -65.0
-          },
-          {
-            lon: 0,
-            lat: -65.0
-          },
-          {
-            lon: 0,
-            lat: 0
-          },
-          {
-            lon: -65.0,
-            lat: 0
-          },
-          {
-            lon: -65.0,
-            lat: -65.0
-          }
-        ]
-      }
-    ]
-  }
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, GeoLineString, GeoPoint, GeoPolygon};
-
-Condition::geo_polygon(
-    "location",
-    GeoPolygon {
-        exterior: Some(GeoLineString {
-            points: vec![
-                GeoPoint {
-                    lon: -70.0,
-                    lat: -70.0,
-                },
-                GeoPoint {
-                    lon: 60.0,
-                    lat: -70.0,
-                },
-                GeoPoint {
-                    lon: 60.0,
-                    lat: 60.0,
-                },
-                GeoPoint {
-                    lon: -70.0,
-                    lat: 60.0,
-                },
-                GeoPoint {
-                    lon: -70.0,
-                    lat: -70.0,
-                },
-            ],
-        }),
-        interiors: vec![GeoLineString {
-            points: vec![
-                GeoPoint {
-                    lon: -65.0,
-                    lat: -65.0,
-                },
-                GeoPoint {
-                    lon: 0.0,
-                    lat: -65.0,
-                },
-                GeoPoint { lon: 0.0, lat: 0.0 },
-                GeoPoint {
-                    lon: -65.0,
-                    lat: 0.0,
-                },
-                GeoPoint {
-                    lon: -65.0,
-                    lat: -65.0,
-                },
-            ],
-        }],
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.geoPolygon;
-
-import io.qdrant.client.grpc.Points.GeoLineString;
-import io.qdrant.client.grpc.Points.GeoPoint;
-
-geoPolygon(
-    "location",
-    GeoLineString.newBuilder()
-        .addAllPoints(
-            List.of(
-                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build(),
-                GeoPoint.newBuilder().setLon(60.0).setLat(-70.0).build(),
-                GeoPoint.newBuilder().setLon(60.0).setLat(60.0).build(),
-                GeoPoint.newBuilder().setLon(-70.0).setLat(60.0).build(),
-                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build()))
-        .build(),
-    List.of(
-        GeoLineString.newBuilder()
-            .addAllPoints(
-                List.of(
-                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build(),
-                    GeoPoint.newBuilder().setLon(0.0).setLat(-65.0).build(),
-                    GeoPoint.newBuilder().setLon(0.0).setLat(0.0).build(),
-                    GeoPoint.newBuilder().setLon(-65.0).setLat(0.0).build(),
-                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build()))
-            .build()));
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-GeoPolygon(
-	field: "location",
-	exterior: new GeoLineString
-	{
-		Points =
-		{
-			new GeoPoint { Lat = -70.0, Lon = -70.0 },
-			new GeoPoint { Lat = 60.0, Lon = -70.0 },
-			new GeoPoint { Lat = 60.0, Lon = 60.0 },
-			new GeoPoint { Lat = -70.0, Lon = 60.0 },
-			new GeoPoint { Lat = -70.0, Lon = -70.0 }
-		}
-	},
-	interiors: [
-		new()
-		{
-			Points =
-			{
-				new GeoPoint { Lat = -65.0, Lon = -65.0 },
-				new GeoPoint { Lat = 0.0, Lon = -65.0 },
-				new GeoPoint { Lat = 0.0, Lon = 0.0 },
-				new GeoPoint { Lat = -65.0, Lon = 0.0 },
-				new GeoPoint { Lat = -65.0, Lon = -65.0 }
-			}
-		}
-	]
-);
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewGeoPolygon("location",
-	&qdrant.GeoLineString{
-		Points: []*qdrant.GeoPoint{
-			{Lat: -70, Lon: -70},
-			{Lat: 60, Lon: -70},
-			{Lat: 60, Lon: 60},
-			{Lat: -70, Lon: 60},
-			{Lat: -70, Lon: -70},
-		},
-	}, &qdrant.GeoLineString{
-		Points: []*qdrant.GeoPoint{
-			{Lat: -65, Lon: -65},
-			{Lat: 0, Lon: -65},
-			{Lat: 0, Lon: 0},
-			{Lat: -65, Lon: 0},
-			{Lat: -65, Lon: -65},
-		},
-	})
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/geo-poligon/" >}}
 
 A match is considered any point location inside or on the boundaries of the given polygon's exterior but not inside any interiors.
 
@@ -2678,63 +399,7 @@ For example, given the data:
 
 We can perform the search only among the items with more than two comments:
 
-```json
-{
-  "key": "comments",
-  "values_count": {
-    "gt": 2
-  }
-}
-```
-
-```python
-models.FieldCondition(
-    key="comments",
-    values_count=models.ValuesCount(gt=2),
-)
-```
-
-```typescript
-{
-    key: 'comments',
-    values_count: {gt: 2}    
-}
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, ValuesCount};
-
-Condition::values_count(
-    "comments",
-    ValuesCount {
-        gt: Some(2),
-        ..Default::default()
-    },
-)
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.valuesCount;
-
-import io.qdrant.client.grpc.Points.ValuesCount;
-
-valuesCount("comments", ValuesCount.newBuilder().setGt(2).build());
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-ValuesCount("comments", new ValuesCount { Gt = 2 });
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewValuesCount("comments", &qdrant.ValuesCount{
-	Gt: qdrant.PtrOf(uint64(2)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/values-count/" >}}
 
 The result would be:
 
@@ -2749,52 +414,7 @@ If stored value is not an array - it is assumed that the amount of values is equ
 Sometimes it is also useful to filter out records that are missing some value.
 The `IsEmpty` condition may help you with that:
 
-```json
-{
-  "is_empty": {
-    "key": "reports"
-  }
-}
-```
-
-```python
-models.IsEmptyCondition(
-    is_empty=models.PayloadField(key="reports"),
-)
-```
-
-```typescript
-{
-  is_empty: {
-    key: "reports"
-  }
-}
-```
-
-```rust
-use qdrant_client::qdrant::Condition;
-
-Condition::is_empty("reports")
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.isEmpty;
-
-isEmpty("reports");
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-IsEmpty("reports");
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewIsEmpty("reports")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/is-empty/" >}}
 
 This condition will match all records where the field `reports` either does not exist, or has `null` or `[]` value.
 
@@ -2805,52 +425,7 @@ This condition will match all records where the field `reports` either does not
 It is not possible to test for `NULL` values with the <b>match</b> condition. 
 We have to use `IsNull` condition instead:
 
-```json
-{
-    "is_null": {
-        "key": "reports"
-    }
-}
-```
-
-```python
-models.IsNullCondition(
-    is_null=models.PayloadField(key="reports"),
-)
-```
-
-```typescript
-{
-  is_null: {
-    key: "reports"
-  }
-}
-```
-
-```rust
-use qdrant_client::qdrant::Condition;
-
-Condition::is_null("reports")
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.isNull;
-
-isNull("reports");
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-IsNull("reports");
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.NewIsNull("reports")
-```
+{{< code-snippet path="/documentation/headless/snippets/filter-condition/is-null/" >}}
 
 This condition will match all records where the field `reports` exists and has `NULL` value.
 
@@ -2860,113 +435,7 @@ This condition will match all records where the field `reports` exists and has `
 This type of query is not related to payload, but can be very useful in some situations.
 For example, the user could mark some specific search results as irrelevant, or we want to search only among the specified points.
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            { "has_id": [1,3,5,7,9,11] }
-        ]
-    }
-    ...
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.HasIdCondition(has_id=[1, 3, 5, 7, 9, 11]),
-        ],
-    ),
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        has_id: [1, 3, 5, 7, 9, 11],
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-    
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}")
-            .filter(Filter::must([Condition::has_id([1, 3, 5, 7, 9, 11])])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.hasId;
-import static io.qdrant.client.PointIdFactory.id;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMust(hasId(List.of(id(1), id(3), id(5), id(7), id(9), id(11))))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(collectionName: "{collection_name}", filter: HasId([1, 3, 5, 7, 9, 11]));
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewHasID(
-				qdrant.NewIDNum(1),
-				qdrant.NewIDNum(3),
-				qdrant.NewIDNum(5),
-				qdrant.NewIDNum(7),
-				qdrant.NewIDNum(9),
-				qdrant.NewIDNum(11),
-			),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-has-id-filter/" >}}
 
 Filtered points would be:
 
@@ -3013,109 +482,4 @@ Some points in the collection might have all vectors, some might have only a sub
 
 This is how you can search for points which have the dense `image` vector defined:
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            { "has_vector": "image" }
-        ]
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.HasVectorCondition(has_vector="image"),
-        ],
-    ),
-)
-```
-
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        has_vector: "image",
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-    
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}")
-            .filter(Filter::must([Condition::has_vector("image")])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.hasVector;
-import static io.qdrant.client.PointIdFactory.id;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(
-                Filter.newBuilder()
-                    .addMust(hasVector("image"))
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(collectionName: "{collection_name}", filter: HasVector("image"));
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewHasVector(
-        "image",
-			),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-has-vector/" >}}
diff --git a/qdrant-landing/content/documentation/concepts/hybrid-queries.md b/qdrant-landing/content/documentation/concepts/hybrid-queries.md
index 012f5c9c5..8146feb2c 100644
--- a/qdrant-landing/content/documentation/concepts/hybrid-queries.md
+++ b/qdrant-landing/content/documentation/concepts/hybrid-queries.md
@@ -52,189 +52,7 @@ Distribution-Based Score Fusion
 
 Here is an example of Reciprocal Rank Fusion for a query containing two prefetches against different named vectors configured to respectively hold sparse and dense vectors. 
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "prefetch": [
-        {
-            "query": { 
-                "indices": [1, 42],    // <┐
-                "values": [0.22, 0.8]  // <┴─sparse vector
-             },
-            "using": "sparse",
-            "limit": 20
-        },
-        {
-            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
-            "using": "dense",
-            "limit": 20
-        }
-    ],
-    "query": { "fusion": "rrf" }, // <--- reciprocal rank fusion
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    prefetch=[
-        models.Prefetch(
-            query=models.SparseVector(indices=[1, 42], values=[0.22, 0.8]),
-            using="sparse",
-            limit=20,
-        ),
-        models.Prefetch(
-            query=[0.01, 0.45, 0.67],  # <-- dense vector
-            using="dense",
-            limit=20,
-        ),
-    ],
-    query=models.FusionQuery(fusion=models.Fusion.RRF),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    prefetch: [
-        {
-            query: {
-                values: [0.22, 0.8],
-                indices: [1, 42],
-            },
-            using: 'sparse',
-            limit: 20,
-        },
-        {
-            query: [0.01, 0.45, 0.67],
-            using: 'dense',
-            limit: 20,
-        },
-    ],
-    query: {
-        fusion: 'rrf',
-    },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Fusion, PrefetchQueryBuilder, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest([(1, 0.22), (42, 0.8)].as_slice()))
-            .using("sparse")
-            .limit(20u64)
-        )
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
-            .using("dense")
-            .limit(20u64)
-        )
-        .query(Query::new_fusion(Fusion::Rrf))
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import java.util.List;
-
-import static io.qdrant.client.QueryFactory.fusion;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Fusion;
-import io.qdrant.client.grpc.Points.PrefetchQuery;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-    QueryPoints.newBuilder()
-    .setCollectionName("{collection_name}")
-    .addPrefetch(PrefetchQuery.newBuilder()
-      .setQuery(nearest(List.of(0.22f, 0.8f), List.of(1, 42)))
-      .setUsing("sparse")
-      .setLimit(20)
-      .build())
-    .addPrefetch(PrefetchQuery.newBuilder()
-      .setQuery(nearest(List.of(0.01f, 0.45f, 0.67f)))
-      .setUsing("dense")
-      .setLimit(20)
-      .build())
-    .setQuery(fusion(Fusion.RRF))
-    .build())
-  .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  prefetch: new List < PrefetchQuery > {
-    new() {
-      Query = new(float, uint)[] {
-          (0.22f, 1), (0.8f, 42),
-        },
-        Using = "sparse",
-        Limit = 20
-    },
-    new() {
-      Query = new float[] {
-          0.01f, 0.45f, 0.67f
-        },
-        Using = "dense",
-        Limit = 20
-    }
-  },
-  query: Fusion.Rrf
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Prefetch: []*qdrant.PrefetchQuery{
-		{
-			Query: qdrant.NewQuerySparse([]uint32{1, 42}, []float32{0.22, 0.8}),
-			Using: qdrant.PtrOf("sparse"),
-		},
-		{
-			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
-			Using: qdrant.PtrOf("dense"),
-		},
-	},
-	Query: qdrant.NewQueryFusion(qdrant.Fusion_RRF),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/hybrid-basic/" >}}
 
 ## Multi-stage queries
 
@@ -258,772 +76,15 @@ such that the coarse results are fetched first, and then they are refined later
 
 Fetch 1000 results using a shorter MRL byte vector, then re-score them using the full vector and get the top 10.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "prefetch": {
-        "query": [1, 23, 45, 67], // <------------- small byte vector
-        "using": "mrl_byte"
-        "limit": 1000
-    },
-    "query": [0.01, 0.299, 0.45, 0.67, ...], // <-- full vector
-    "using": "full",
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    prefetch=models.Prefetch(
-        query=[1, 23, 45, 67],  # <------------- small byte vector
-        using="mrl_byte",
-        limit=1000,
-    ),
-    query=[0.01, 0.299, 0.45, 0.67],  # <-- full vector
-    using="full",
-    limit=10,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  prefetch: {
-    query: [1, 23, 45, 67], // <------------- small byte vector
-    using: 'mrl_byte',
-    limit: 1000,
-  },
-  query: [0.01, 0.299, 0.45, 0.67], // <-- full vector,
-  using: 'full',
-  limit: 10,
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest(vec![1.0, 23.0, 45.0, 67.0]))
-            .using("mlr_byte")
-            .limit(1000u64)
-        )
-        .query(Query::new_nearest(vec![0.01, 0.299, 0.45, 0.67]))
-        .using("full")
-        .limit(10u64)
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PrefetchQuery;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .addPrefetch(
-                PrefetchQuery.newBuilder()
-                    .setQuery(nearest(1, 23, 45, 67))	// <------------- small byte vector
-                    .setLimit(1000)
-                    .setUsing("mrl_byte")
-                    .build())
-            .setQuery(nearest(0.01f, 0.299f, 0.45f, 0.67f))	 // <-- full vector
-            .setUsing("full")
-            .setLimit(10)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  prefetch: new List<PrefetchQuery> {
-    new() {
-      Query = new float[] { 1,23, 45, 67 }, // <------------- small byte vector
-        Using = "mrl_byte",
-        Limit = 1000
-    }
-  },
-  query: new float[] { 0.01f, 0.299f, 0.45f, 0.67f }, // <-- full vector
-  usingVector: "full",
-  limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Prefetch: []*qdrant.PrefetchQuery{
-		{
-			Query: qdrant.NewQueryDense([]float32{1, 23, 45, 67}),
-			Using: qdrant.PtrOf("mrl_byte"),
-			Limit: qdrant.PtrOf(uint64(1000)),
-		},
-	},
-	Query: qdrant.NewQueryDense([]float32{0.01, 0.299, 0.45, 0.67}),
-	Using: qdrant.PtrOf("full"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/hybrid-rescoring/" >}}
 
 Fetch 100 results using the default vector, then re-score them using a multi-vector to get the top 10.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "prefetch": {
-        "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
-        "limit": 100
-    },
-    "query": [           // <─┐
-        [0.1, 0.2, ...], // < │
-        [0.2, 0.1, ...], // < ├─ multi-vector
-        [0.8, 0.9, ...]  // < │
-    ],                   // <─┘       
-    "using": "colbert",
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    prefetch=models.Prefetch(
-        query=[0.01, 0.45, 0.67, 0.53],  # <-- dense vector
-        limit=100,
-    ),
-    query=[
-        [0.1, 0.2, 0.32],  # <─┐
-        [0.2, 0.1, 0.52],  # < ├─ multi-vector
-        [0.8, 0.9, 0.93],  # < ┘
-    ],
-    using="colbert",
-    limit=10,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    prefetch: {
-        query: [1, 23, 45, 67], // <------------- small byte vector
-        limit: 100,
-    },
-    query: [
-        [0.1, 0.2], // <─┐
-        [0.2, 0.1], // < ├─ multi-vector
-        [0.8, 0.9], // < ┘
-    ],
-    using: 'colbert',
-    limit: 10,
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
-            .limit(100u64)
-        )
-        .query(Query::new_nearest(vec![
-            vec![0.1, 0.2],
-            vec![0.2, 0.1],
-            vec![0.8, 0.9],
-        ]))
-        .using("colbert")
-        .limit(10u64)
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PrefetchQuery;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .addPrefetch(
-                PrefetchQuery.newBuilder()
-                    .setQuery(nearest(0.01f, 0.45f, 0.67f)) // <-- dense vector
-                    .setLimit(100)
-                    .build())
-            .setQuery(
-                nearest(
-                    new float[][] {
-                      {0.1f, 0.2f},	// <─┐
-                      {0.2f, 0.1f},	// < ├─ multi-vector
-                      {0.8f, 0.9f}	// < ┘
-                    }))
-            .setUsing("colbert")
-            .setLimit(10)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  prefetch: new List <PrefetchQuery> {
-    new() {
-      Query = new float[] { 0.01f, 0.45f, 0.67f	},	// <-- dense vector****
-        Limit = 100
-    }
-  },
-  query: new float[][] {
-    [0.1f, 0.2f], // <─┐
-    [0.2f, 0.1f], // < ├─ multi-vector
-    [0.8f, 0.9f]  // < ┘
-  },
-  usingVector: "colbert",
-  limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Prefetch: []*qdrant.PrefetchQuery{
-		{
-			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
-			Limit: qdrant.PtrOf(uint64(100)),
-		},
-	},
-	Query: qdrant.NewQueryMulti([][]float32{
-		{0.1, 0.2},
-		{0.2, 0.1},
-		{0.8, 0.9},
-	}),
-	Using: qdrant.PtrOf("colbert"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/" >}}
 
 It is possible to combine all the above techniques in a single query:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "prefetch": {
-        "prefetch": {
-            "query": [1, 23, 45, 67], // <------ small byte vector
-            "using": "mrl_byte"
-            "limit": 1000
-        },
-        "query": [0.01, 0.45, 0.67, ...], // <-- full dense vector
-        "using": "full"
-        "limit": 100
-    },
-    "query": [           // <─┐
-        [0.1, 0.2, ...], // < │
-        [0.2, 0.1, ...], // < ├─ multi-vector
-        [0.8, 0.9, ...]  // < │
-    ],                   // <─┘       
-    "using": "colbert",
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    prefetch=models.Prefetch(
-        prefetch=models.Prefetch(
-            query=[1, 23, 45, 67],  # <------ small byte vector
-            using="mrl_byte",
-            limit=1000,
-        ),
-        query=[0.01, 0.45, 0.67],  # <-- full dense vector
-        using="full",
-        limit=100,
-    ),
-    query=[
-        [0.17, 0.23, 0.52],  # <─┐
-        [0.22, 0.11, 0.63],  # < ├─ multi-vector
-        [0.86, 0.93, 0.12],  # < ┘
-    ],
-    using="colbert",
-    limit=10,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  prefetch: {
-    prefetch: {
-      query: [1, 23, 45, 67], // <------------- small byte vector
-      using: 'mrl_byte',
-      limit: 1000,
-    },
-    query: [0.01, 0.45, 0.67],  // <-- full dense vector
-    using: 'full',
-    limit: 100,
-  },
-  query: [
-    [0.1, 0.2], // <─┐
-    [0.2, 0.1], // < ├─ multi-vector
-    [0.8, 0.9], // < ┘
-  ],
-  using: 'colbert',
-  limit: 10,
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .add_prefetch(PrefetchQueryBuilder::default()
-                .query(Query::new_nearest(vec![1.0, 23.0, 45.0, 67.0]))
-                .using("mlr_byte")
-                .limit(1000u64)
-            )
-            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
-            .using("full")
-            .limit(100u64)
-        )
-        .query(Query::new_nearest(vec![
-            vec![0.1, 0.2],
-            vec![0.2, 0.1],
-            vec![0.8, 0.9],
-        ]))
-        .using("colbert")
-        .limit(10u64)
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PrefetchQuery;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .addPrefetch(
-                PrefetchQuery.newBuilder()
-                    .addPrefetch(
-                        PrefetchQuery.newBuilder()
-                            .setQuery(nearest(1, 23, 45, 67))	// <------------- small byte vector
-                            .setUsing("mrl_byte")
-                            .setLimit(1000)
-                            .build())
-                    .setQuery(nearest(0.01f, 0.45f, 0.67f)) // <-- dense vector
-                    .setUsing("full")
-                    .setLimit(100)
-                    .build())
-            .setQuery(
-                nearest(
-                    new float[][] {
-                      {0.1f, 0.2f},	// <─┐
-                      {0.2f, 0.1f},	// < ├─ multi-vector
-                      {0.8f, 0.9f}	// < ┘
-                    }))
-            .setUsing("colbert")
-            .setLimit(10)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  prefetch: new List <PrefetchQuery> {
-    new() {
-      Prefetch = {
-          new List <PrefetchQuery> {
-            new() {
-              Query = new float[] { 1, 23, 45, 67 }, // <------------- small byte vector
-                Using = "mrl_byte",
-                Limit = 1000
-            },
-          }
-        },
-        Query = new float[] {0.01f, 0.45f, 0.67f}, // <-- dense vector
-        Using = "full",
-        Limit = 100
-    }
-  },
-  query: new float[][] {
-    [0.1f, 0.2f], // <─┐
-    [0.2f, 0.1f], // < ├─ multi-vector
-    [0.8f, 0.9f]  // < ┘
-  },
-  usingVector: "colbert",
-  limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Prefetch: []*qdrant.PrefetchQuery{
-		{
-			Prefetch: []*qdrant.PrefetchQuery{
-				{
-					Query: qdrant.NewQueryDense([]float32{1, 23, 45, 67}),
-					Using: qdrant.PtrOf("mrl_byte"),
-					Limit: qdrant.PtrOf(uint64(1000)),
-				},
-			},
-			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
-			Limit: qdrant.PtrOf(uint64(100)),
-			Using: qdrant.PtrOf("full"),
-		},
-	},
-	Query: qdrant.NewQueryMulti([][]float32{
-		{0.1, 0.2},
-		{0.2, 0.1},
-		{0.8, 0.9},
-	}),
-	Using: qdrant.PtrOf("colbert"),
-})
-```
-
-## Flexible interface
-
-Other than the introduction of `prefetch`, the `Query API` has been designed to make querying simpler. Let's look at a few bonus features:
-
-### Query by ID
-
-Whenever you need to use a vector as an input, you can always use a [point ID](/documentation/concepts/points/#point-ids) instead.
-
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": "43cf51e2-8777-4f52-bc74-c2cbde0c8b04" // <--- point id
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04",  # <--- point id
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: '43cf51e2-8777-4f52-bc74-c2cbde0c8b04', // <--- point id
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Condition, Filter, PointId, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(Query::new_nearest("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import java.util.UUID;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setQuery(nearest(UUID.fromString("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: Guid.Parse("43cf51e2-8777-4f52-bc74-c2cbde0c8b04") // <--- point id
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQueryID(qdrant.NewID("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
-})
-```
-
-The above example will fetch the default vector from the point with this id, and use it as the query vector.
-
-If the `using` parameter is also specified, Qdrant will use the vector with that name.
-
-It is also possible to reference an ID from a different collection, by setting the `lookup_from` parameter.
-
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": "43cf51e2-8777-4f52-bc74-c2cbde0c8b04", // <--- point id
-    "using": "512d-vector"
-    "lookup_from": {
-        "collection": "another_collection", // <--- other collection name
-        "vector": "image-512" // <--- vector name in the other collection
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04",  # <--- point id
-    using="512d-vector",
-    lookup_from=models.LookupLocation(
-        collection="another_collection",  # <--- other collection name
-        vector="image-512",  # <--- vector name in the other collection
-    )
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: '43cf51e2-8777-4f52-bc74-c2cbde0c8b04', // <--- point id
-    using: '512d-vector',
-    lookup_from: {
-        collection: 'another_collection', // <--- other collection name
-        vector: 'image-512', // <--- vector name in the other collection
-    }
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{LookupLocationBuilder, PointId, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .query(Query::new_nearest("43cf51e2-8777-4f52-bc74-c2cbde0c8b04"))
-        .using("512d-vector")
-        .lookup_from(
-            LookupLocationBuilder::new("another_collection")
-                .vector_name("image-512")
-        )
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.LookupLocation;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import java.util.UUID;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setQuery(nearest(UUID.fromString("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
-            .setUsing("512d-vector")
-            .setLookupFrom(
-                LookupLocation.newBuilder()
-                    .setCollectionName("another_collection")
-                    .setVectorName("image-512")
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  query: Guid.Parse("43cf51e2-8777-4f52-bc74-c2cbde0c8b04"), // <--- point id
-  usingVector: "512d-vector",
-  lookupFrom: new() {
-    CollectionName = "another_collection", // <--- other collection name
-      VectorName = "image-512" // <--- vector name in the other collection
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQueryID(qdrant.NewID("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
-	Using:          qdrant.PtrOf("512d-vector"),
-	LookupFrom: &qdrant.LookupLocation{
-		CollectionName: "another_collection",
-		VectorName:     qdrant.PtrOf("image-512"),
-	},
-})
-```
-
-In the case above, Qdrant will fetch the `"image-512"` vector from the specified point id in the 
-collection `another_collection`.
-
-<aside role="status">
- The fetched vector(s) must match the characteristics of the <code>using</code> vector, otherwise, an error will be returned.
-</aside>
+{{< code-snippet path="/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/" >}}
 
 
 ## Re-ranking with payload values
@@ -1037,364 +98,9 @@ There are two ways to make use of the payload in the query:
 
 Let's see an example of when this might be useful:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "prefetch": [
-        {
-            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
-            "filter": {
-                "must": {
-                    "key": "color",
-                    "match": {
-                        "value": "red"
-                    }
-                }
-            },
-            "limit": 10
-        },
-        {
-            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
-            "filter": {
-                "must": {
-                    "key": "color",
-                    "match": {
-                        "value": "green"
-                    }
-                }
-            },
-            "limit": 10
-        }
-    ],
-    "query": { "order_by": "price" }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    prefetch=[
-        models.Prefetch(
-            query=[0.01, 0.45, 0.67],  # <-- dense vector
-            filter=models.Filter(
-                must=models.FieldCondition(
-                    key="color",
-                    match=models.MatchValue(value="red"),
-                ),
-            ),
-            limit=10,
-        ),
-        models.Prefetch(
-            query=[0.01, 0.45, 0.67],  # <-- dense vector
-            filter=models.Filter(
-                must=models.FieldCondition(
-                    key="color",
-                    match=models.MatchValue(value="green"),
-                ),
-            ),
-            limit=10,
-        ),
-    ],
-    query=models.OrderByQuery(order_by="price"),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    prefetch: [
-        {
-            query: [0.01, 0.45, 0.67], // <-- dense vector
-            filter: {
-                must: {
-                    key: 'color',
-                    match: {
-                        value: 'red',
-                    },
-                }
-            },
-            limit: 10,
-        },
-        {
-            query: [0.01, 0.45, 0.67], // <-- dense vector
-            filter: {
-                must: {
-                    key: 'color',
-                    match: {
-                        value: 'green',
-                    },
-                }
-            },
-            limit: 10,
-        },
-    ],
-    query: {
-        order_by: 'price',
-    },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Condition, Filter, PrefetchQueryBuilder, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
-            .filter(Filter::must([Condition::matches(
-                "color",
-                "red".to_string(),
-            )]))
-            .limit(10u64)
-        )
-        .add_prefetch(PrefetchQueryBuilder::default()
-            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
-            .filter(Filter::must([Condition::matches(
-                "color",
-                "green".to_string(),
-            )]))
-            .limit(10u64)
-        )
-        .query(Query::new_order_by("price"))
-).await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.QueryFactory.orderBy;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.PrefetchQuery;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .addPrefetch(
-                PrefetchQuery.newBuilder()
-                    .setQuery(nearest(0.01f, 0.45f, 0.67f))
-                    .setFilter(
-                        Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-                    .setLimit(10)
-                    .build())
-            .addPrefetch(
-                PrefetchQuery.newBuilder()
-                    .setQuery(nearest(0.01f, 0.45f, 0.67f))
-                    .setFilter(
-                        Filter.newBuilder().addMust(matchKeyword("color", "green")).build())
-                    .setLimit(10)
-                    .build())
-            .setQuery(orderBy("price"))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  prefetch: new List <PrefetchQuery> {
-    new() {
-      Query = new float[] {
-          0.01f, 0.45f, 0.67f
-        },
-        Filter = MatchKeyword("color", "red"),
-        Limit = 10
-    },
-    new() {
-      Query = new float[] {
-          0.01f, 0.45f, 0.67f
-        },
-        Filter = MatchKeyword("color", "green"),
-        Limit = 10
-    }
-  },
-  query: (OrderBy) "price",
-  limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Prefetch: []*qdrant.PrefetchQuery{
-		{
-			Query: qdrant.NewQuery(0.01, 0.45, 0.67),
-			Filter: &qdrant.Filter{
-				Must: []*qdrant.Condition{
-					qdrant.NewMatch("color", "red"),
-				},
-			},
-		},
-		{
-			Query: qdrant.NewQuery(0.01, 0.45, 0.67),
-			Filter: &qdrant.Filter{
-				Must: []*qdrant.Condition{
-					qdrant.NewMatch("color", "green"),
-				},
-			},
-		},
-	},
-	Query: qdrant.NewQueryOrderBy(&qdrant.OrderBy{
-		Key: "price",
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/" >}}
 
 In this example, we first fetch 10 points with the color `"red"` and then 10 points with the color `"green"`.
 Then, we order the results by the price field.
 
 This is how we can guarantee even sampling of both colors in the results and also get the cheapest ones first.
-
-## Grouping
-
-*Available as of v1.11.0*
-
-It is possible to group results by a certain field. This is useful when you have multiple points for the same item, and you want to avoid redundancy of the same item in the results.
-
-REST API ([Schema](https://api.qdrant.tech/master/api-reference/search/query-points-groups)):
-
-```http
-POST /collections/{collection_name}/points/query/groups
-{
-    "query": [0.01, 0.45, 0.67],
-    group_by="document_id",  # Path of the field to group by
-    limit=4,  # Max amount of groups
-    group_size=2,  # Max amount of points per group
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points_groups(
-    collection_name="{collection_name}",
-    query=[0.01, 0.45, 0.67],
-    group_by="document_id",
-    limit=4,
-    group_size=2,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.queryGroups("{collection_name}", {
-    query: [0.01, 0.45, 0.67],
-    group_by: "document_id",
-    limit: 4,
-    group_size: 2,
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.query_groups(
-    QueryPointGroupsBuilder::new("{collection_name}", "document_id")
-        .query(Query::from(vec![0.01, 0.45, 0.67]))
-        .limit(4u64)
-        .group_size(2u64)
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPointGroups;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .queryGroupsAsync(
-        QueryPointGroups.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setGroupBy("document_id")
-            .setQuery(nearest(0.01f, 0.45f, 0.67f))
-            .setLimit(4)
-            .setGroupSize(2)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryGroupsAsync(
-  collectionName: "{collection_name}",
-  groupBy: "document_id",
-  query: new float[] {
-    0.01f, 0.45f, 0.67f
-  },
-  limit: 4,
-  groupSize: 2
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.01, 0.45, 0.67),
-	GroupBy:        "document_id",
-	GroupSize:      qdrant.PtrOf(uint64(2)),
-})
-```
-
-For more information on the `grouping` capabilities refer to the reference documentation for search with [grouping](/documentation/concepts/search/#search-groups) and [lookup](/documentation/concepts/search/#lookup-in-groups).
diff --git a/qdrant-landing/content/documentation/concepts/indexing.md b/qdrant-landing/content/documentation/concepts/indexing.md
index 59da82e54..bb8385c61 100644
--- a/qdrant-landing/content/documentation/concepts/indexing.md
+++ b/qdrant-landing/content/documentation/concepts/indexing.md
@@ -25,99 +25,7 @@ Creating an index requires additional computational resources and memory, so cho
 
 To mark a field as indexable, you can use the following:
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "name_of_the_field_to_index",
-    "field_schema": "keyword"
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="name_of_the_field_to_index",
-    field_schema=models.PayloadSchemaType.KEYWORD,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createPayloadIndex("{collection_name}", {
-  field_name: "name_of_the_field_to_index",
-  field_schema: "keyword",
-});
-```
-
-```rust
-use qdrant_client::qdrant::{CreateFieldIndexCollectionBuilder, FieldType};
-
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_field_index(CreateFieldIndexCollectionBuilder::new(
-        "{collection_name}",
-        "name_of_the_field_to_index",
-        FieldType::Keyword,
-    ))
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "name_of_the_field_to_index",
-        PayloadSchemaType.Keyword,
-        null,
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(collectionName: "{collection_name}", fieldName: "name_of_the_field_to_index");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/simple-keyword/" >}}
 
 You can use dot notation to specify a nested field for indexing. Similar to specifying [nested filters](/documentation/concepts/filtering/#nested-key).
 
@@ -149,162 +57,7 @@ Tokenization is the process of splitting a string into tokens, which are then in
 
 To create a full-text index, you can use the following:
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "name_of_the_field_to_index",
-    "field_schema": {
-        "type": "text",
-        "tokenizer": "word",
-        "min_token_len": 2,
-        "max_token_len": 20,
-        "lowercase": true
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="name_of_the_field_to_index",
-    field_schema=models.TextIndexParams(
-        type="text",
-        tokenizer=models.TokenizerType.WORD,
-        min_token_len=2,
-        max_token_len=15,
-        lowercase=True,
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createPayloadIndex("{collection_name}", {
-  field_name: "name_of_the_field_to_index",
-  field_schema: {
-    type: "text",
-    tokenizer: "word",
-    min_token_len: 2,
-    max_token_len: 15,
-    lowercase: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    payload_index_params::IndexParams, CreateFieldIndexCollectionBuilder, FieldType,
-    PayloadIndexParams, TextIndexParams, TokenizerType,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_field_index(
-        CreateFieldIndexCollectionBuilder::new(
-            "{collection_name}",
-            "name_of_the_field_to_index",
-            FieldType::Text,
-        )
-        .field_index_params(PayloadIndexParams {
-            index_params: Some(IndexParams::TextIndexParams(TextIndexParams {
-                tokenizer: TokenizerType::Word as i32,
-                min_token_len: Some(2),
-                max_token_len: Some(10),
-                lowercase: Some(true),
-            })),
-        }),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-import io.qdrant.client.grpc.Collections.TextIndexParams;
-import io.qdrant.client.grpc.Collections.TokenizerType;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "name_of_the_field_to_index",
-        PayloadSchemaType.Text,
-        PayloadIndexParams.newBuilder()
-            .setTextIndexParams(
-                TextIndexParams.newBuilder()
-                    .setTokenizer(TokenizerType.Word)
-                    .setMinTokenLen(2)
-                    .setMaxTokenLen(10)
-                    .setLowercase(true)
-                    .build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
-	collectionName: "{collection_name}",
-	fieldName: "name_of_the_field_to_index",
-	schemaType: PayloadSchemaType.Text,
-	indexParams: new PayloadIndexParams
-	{
-		TextIndexParams = new TextIndexParams
-		{
-			Tokenizer = TokenizerType.Word,
-			MinTokenLen = 2,
-			MaxTokenLen = 10,
-			Lowercase = true
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeText.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParamsText(
-		&qdrant.TextIndexParams{
-			Tokenizer:   qdrant.TokenizerType_Whitespace,
-			MinTokenLen: qdrant.PtrOf(uint64(2)),
-			MaxTokenLen: qdrant.PtrOf(uint64(10)),
-			Lowercase:   qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/simple-full-text/" >}}
 
 Available tokenizers are:
 
@@ -350,144 +103,7 @@ significant performance issues.
 For example, the following code sets up a parameterized integer index which
 supports only range filters:
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "name_of_the_field_to_index",
-    "field_schema": {
-        "type": "integer",
-        "lookup": false,
-        "range": true
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="name_of_the_field_to_index",
-    field_schema=models.IntegerIndexParams(
-        type=models.IntegerIndexType.INTEGER,
-        lookup=False,
-        range=True,
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createPayloadIndex("{collection_name}", {
-  field_name: "name_of_the_field_to_index",
-  field_schema: {
-    type: "integer",
-    lookup: false,
-    range: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    payload_index_params::IndexParams, CreateFieldIndexCollectionBuilder, FieldType,
-    IntegerIndexParams, PayloadIndexParams,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_field_index(
-        CreateFieldIndexCollectionBuilder::new(
-            "{collection_name}",
-            "name_of_the_field_to_index",
-            FieldType::Integer,
-        )
-        .field_index_params(PayloadIndexParams {
-            index_params: Some(IndexParams::IntegerIndexParams(IntegerIndexParams {
-                lookup: false,
-                range: true,
-            })),
-        }),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.IntegerIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "name_of_the_field_to_index",
-        PayloadSchemaType.Integer,
-        PayloadIndexParams.newBuilder()
-            .setIntegerIndexParams(
-                IntegerIndexParams.newBuilder().setLookup(false).setRange(true).build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
-    collectionName: "{collection_name}",
-    fieldName: "name_of_the_field_to_index",
-    schemaType: PayloadSchemaType.Integer,
-    indexParams: new PayloadIndexParams
-    {
-	    IntegerIndexParams = new()
-	    {
-		    Lookup = false,
-		    Range = true
-	    }
-    }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeInteger.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParamsInt(
-		&qdrant.IntegerIndexParams{
-			Lookup: false,
-			Range:  true,
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/integer-with-params/" >}}
 
 ### On-disk payload index
 
@@ -504,130 +120,7 @@ There are, however, cases when payload indexes are too large or rarely used. In
 
 To configure on-disk payload index, you can use the following index parameters:
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "payload_field_name",
-    "field_schema": {
-        "type": "keyword",
-        "on_disk": true
-    }
-}
-```
-
-```python
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="payload_field_name",
-    field_schema=models.KeywordIndexParams(
-        type=models.KeywordIndexType.KEYWORD,
-        on_disk=True,
-    ),
-)
-```
-
-```typescript
-client.createPayloadIndex("{collection_name}", {
-  field_name: "payload_field_name",
-  field_schema: {
-    type: "keyword",
-    on_disk: true
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateFieldIndexCollectionBuilder,
-    KeywordIndexParamsBuilder,
-    FieldType
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_field_index(
-    CreateFieldIndexCollectionBuilder::new(
-        "{collection_name}",
-        "payload_field_name",
-        FieldType::Keyword,
-    )
-    .field_index_params(
-        KeywordIndexParamsBuilder::default()
-            .on_disk(true),
-    ),
-);
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-import io.qdrant.client.grpc.Collections.KeywordIndexParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "payload_field_name",
-        PayloadSchemaType.Keyword,
-        PayloadIndexParams.newBuilder()
-            .setKeywordIndexParams(
-                KeywordIndexParams.newBuilder()
-                    .setOnDisk(true)
-                    .build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
- collectionName: "{collection_name}",
- fieldName: "payload_field_name",
- schemaType: PayloadSchemaType.Keyword,
- indexParams: new PayloadIndexParams
- {
-  KeywordIndexParams = new KeywordIndexParams
-  {
-   OnDisk   = true
-  }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParamsKeyword(
-		&qdrant.KeywordIndexParams{
-			OnDisk: qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/keyword-on-disk/" >}}
 
 Payload index on-disk is supported for following types:
 
@@ -661,130 +154,7 @@ One example of such optimization is localizing tenant-specific data closer on di
 
 To enable tenant index for a field, you can use the following index parameters:
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "payload_field_name",
-    "field_schema": {
-        "type": "keyword",
-        "is_tenant": true
-    }
-}
-```
-
-```python
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="payload_field_name",
-    field_schema=models.KeywordIndexParams(
-        type=models.KeywordIndexType.KEYWORD,
-        is_tenant=True,
-    ),
-)
-```
-
-```typescript
-client.createPayloadIndex("{collection_name}", {
-  field_name: "payload_field_name",
-  field_schema: {
-    type: "keyword",
-    is_tenant: true
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateFieldIndexCollectionBuilder,
-    KeywordIndexParamsBuilder,
-    FieldType
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_field_index(
-    CreateFieldIndexCollectionBuilder::new(
-        "{collection_name}",
-        "payload_field_name",
-        FieldType::Keyword,
-    )
-    .field_index_params(
-        KeywordIndexParamsBuilder::default()
-            .is_tenant(true),
-    ),
-);
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-import io.qdrant.client.grpc.Collections.KeywordIndexParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "payload_field_name",
-        PayloadSchemaType.Keyword,
-        PayloadIndexParams.newBuilder()
-            .setKeywordIndexParams(
-                KeywordIndexParams.newBuilder()
-                    .setIsTenant(true)
-                    .build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
- collectionName: "{collection_name}",
- fieldName: "payload_field_name",
- schemaType: PayloadSchemaType.Keyword,
- indexParams: new PayloadIndexParams
- {
-  KeywordIndexParams = new KeywordIndexParams
-  {
-   IsTenant = true
-  }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParamsKeyword(
-		&qdrant.KeywordIndexParams{
-			IsTenant: qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/keyword-is-tenant/" >}}
 
 Tenant optimization is supported for the following datatypes:
 
@@ -799,130 +169,7 @@ Similar to the tenant index, the principal index is used to optimize storage for
 
 A good example of a use case for the principal index is time-related data, where each point is associated with a timestamp. In this case, the principal index can be used to optimize storage for faster search with time-based filters.
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "timestamp",
-    "field_schema": {
-        "type": "integer",
-        "is_principal": true
-    }
-}
-```
-
-```python
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="timestamp",
-    field_schema=models.IntegerIndexParams(
-        type=models.IntegerIndexType.INTEGER,
-        is_principal=True,
-    ),
-)
-```
-
-```typescript
-client.createPayloadIndex("{collection_name}", {
-  field_name: "timestamp",
-  field_schema: {
-    type: "integer",
-    is_principal: true
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateFieldIndexCollectionBuilder,
-    IntegerIndexParamsBuilder,
-    FieldType
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_field_index(
-    CreateFieldIndexCollectionBuilder::new(
-        "{collection_name}",
-        "timestamp",
-        FieldType::Integer,
-    )
-    .field_index_params(
-        IntegerIndexParamsBuilder::default()
-            .is_principal(true),
-    ),
-);
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-import io.qdrant.client.grpc.Collections.IntegerIndexParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "timestamp",
-        PayloadSchemaType.Integer,
-        PayloadIndexParams.newBuilder()
-            .setIntegerIndexParams(
-                KeywordIndexParams.newBuilder()
-                    .setIsPrincipa(true)
-                    .build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
- collectionName: "{collection_name}",
- fieldName: "timestamp",
- schemaType: PayloadSchemaType.Integer,
- indexParams: new PayloadIndexParams
- {
-  IntegerIndexParams = new IntegerIndexParams
-  {
-   IsPrincipal = true
-  }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "name_of_the_field_to_index",
-	FieldType:      qdrant.FieldType_FieldTypeInteger.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParamsInt(
-		&qdrant.IntegerIndexParams{
-			IsPrincipal: qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/integer-is-principal/" >}}
 
 Principal optimization is supported for following types:
 
@@ -989,143 +236,7 @@ This approach is particularly useful for collections storing both dense and spar
 
 To configure a sparse vector index, create a collection with the following parameters:
 
-```http
-PUT /collections/{collection_name}
-{
-    "sparse_vectors": {
-        "text": {
-            "index": {
-                "on_disk": false
-            }
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={},
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(
-            index=models.SparseIndexParams(on_disk=False),
-        )
-    },
-)
-```
-
-```typescript
-import { QdrantClient, Schemas } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  sparse_vectors: {
-    "splade-model-name": {
-      index: {
-        on_disk: false
-      }
-    }
-  }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, SparseIndexConfigBuilder, SparseVectorParamsBuilder,
-    SparseVectorsConfigBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
-
-sparse_vectors_config.add_named_vector_params(
-    "splade-model-name",
-    SparseVectorParamsBuilder::default()
-        .index(SparseIndexConfigBuilder::default().on_disk(true)),
-);
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .sparse_vectors_config(sparse_vectors_config),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-import io.qdrant.client.grpc.Collections;
-
-QdrantClient client = new QdrantClient(
-    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.createCollectionAsync(
-    Collections.CreateCollection.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setSparseVectorsConfig(
-            Collections.SparseVectorConfig.newBuilder().putMap(
-                "splade-model-name",
-                Collections.SparseVectorParams.newBuilder()
-                    .setIndex(
-                        Collections.SparseIndexConfig
-                            .newBuilder()
-                            .setOnDisk(false)
-                            .build()
-                    ).build()
-            ).build()
-        ).build()
-).get();
-
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	sparseVectorsConfig: ("splade-model-name", new SparseVectorParams{
-        Index = new SparseIndexConfig {
-            OnDisk = false,
-        }
-    })
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"splade-model-name": {
-				Index: &qdrant.SparseIndexConfig{
-					OnDisk: qdrant.PtrOf(false),
-				}},
-		}),
-})
-````
+{{< code-snippet path="/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/" >}}`
 
 The following parameters may affect performance:
 
@@ -1150,128 +261,7 @@ In order to support IDF in the sparse vector index, Qdrant provides an option to
 
 The only requirement is to enable the IDF modifier in the collection configuration:
 
-```http
-PUT /collections/{collection_name}
-{
-    "sparse_vectors": {
-        "text": {
-            "modifier": "idf"
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={},
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(
-            modifier=models.Modifier.IDF,
-        ),
-    },
-)
-```
-
-```typescript
-import { QdrantClient, Schemas } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  sparse_vectors: {
-    "text": {
-      modifier: "idf"
-    }
-  }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Modifier, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
-sparse_vectors_config.add_named_vector_params(
-    "text",
-    SparseVectorParamsBuilder::default().modifier(Modifier::Idf),
-);
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .sparse_vectors_config(sparse_vectors_config),
-    )
-    .await?;
-```
-
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Modifier;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-
-QdrantClient client =
-  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-  .createCollectionAsync(
-    CreateCollection.newBuilder()
-    .setCollectionName("{collection_name}")
-    .setSparseVectorsConfig(
-      SparseVectorConfig.newBuilder()
-      .putMap("text", SparseVectorParams.newBuilder().setModifier(Modifier.Idf).build()))
-    .build())
-  .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  sparseVectorsConfig: ("text", new SparseVectorParams {
-    Modifier = Modifier.Idf,
-  })
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text": {
-				Modifier: qdrant.Modifier_Idf.Enum(),
-			},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/sparse-vector-idf/" >}}
 
 Qdrant uses the following formula to calculate the IDF modifier:
 
diff --git a/qdrant-landing/content/documentation/concepts/payload.md b/qdrant-landing/content/documentation/concepts/payload.md
index ab9e433ca..caef75f47 100644
--- a/qdrant-landing/content/documentation/concepts/payload.md
+++ b/qdrant-landing/content/documentation/concepts/payload.md
@@ -199,250 +199,7 @@ Usage of `uuid` index type is recommended in payload-heavy collections to save R
 ## Create point with payload
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/upsert-points))
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": [0.05, 0.61, 0.76, 0.74],
-            "payload": {"city": "Berlin", "price": 1.99}
-        },
-        {
-            "id": 2,
-            "vector": [0.19, 0.81, 0.75, 0.11],
-            "payload": {"city": ["Berlin", "London"], "price": 1.99}
-        },
-        {
-            "id": 3,
-            "vector": [0.36, 0.55, 0.47, 0.94],
-            "payload": {"city": ["Berlin", "Moscow"], "price": [1.99, 2.99]}
-        }
-    ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            vector=[0.05, 0.61, 0.76, 0.74],
-            payload={
-                "city": "Berlin",
-                "price": 1.99,
-            },
-        ),
-        models.PointStruct(
-            id=2,
-            vector=[0.19, 0.81, 0.75, 0.11],
-            payload={
-                "city": ["Berlin", "London"],
-                "price": 1.99,
-            },
-        ),
-        models.PointStruct(
-            id=3,
-            vector=[0.36, 0.55, 0.47, 0.94],
-            payload={
-                "city": ["Berlin", "Moscow"],
-                "price": [1.99, 2.99],
-            },
-        ),
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: [0.05, 0.61, 0.76, 0.74],
-      payload: {
-        city: "Berlin",
-        price: 1.99,
-      },
-    },
-    {
-      id: 2,
-      vector: [0.19, 0.81, 0.75, 0.11],
-      payload: {
-        city: ["Berlin", "London"],
-        price: 1.99,
-      },
-    },
-    {
-      id: 3,
-      vector: [0.36, 0.55, 0.47, 0.94],
-      payload: {
-        city: ["Berlin", "Moscow"],
-        price: [1.99, 2.99],
-      },
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-use qdrant_client::{Payload, Qdrant, QdrantError};
-use serde_json::json;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let points = vec![
-    PointStruct::new(
-        1,
-        vec![0.05, 0.61, 0.76, 0.74],
-        Payload::try_from(json!({"city": "Berlin", "price": 1.99})).unwrap(),
-    ),
-    PointStruct::new(
-        2,
-        vec![0.19, 0.81, 0.75, 0.11],
-        Payload::try_from(json!({"city": ["Berlin", "London"]})).unwrap(),
-    ),
-    PointStruct::new(
-        3,
-        vec![0.36, 0.55, 0.47, 0.94],
-        Payload::try_from(json!({"city": ["Berlin", "Moscow"], "price": [1.99, 2.99]}))
-            .unwrap(),
-    ),
-];
-
-client
-    .upsert_points(UpsertPointsBuilder::new("{collection_name}", points).wait(true))
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-import static io.qdrant.client.VectorsFactory.vectors;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
-                .putAllPayload(Map.of("city", value("Berlin"), "price", value(1.99)))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(2))
-                .setVectors(vectors(0.19f, 0.81f, 0.75f, 0.11f))
-                .putAllPayload(
-                    Map.of("city", list(List.of(value("Berlin"), value("London")))))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(3))
-                .setVectors(vectors(0.36f, 0.55f, 0.47f, 0.94f))
-                .putAllPayload(
-                    Map.of(
-                        "city",
-                        list(List.of(value("Berlin"), value("London"))),
-                        "price",
-                        list(List.of(value(1.99), value(2.99)))))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-    collectionName: "{collection_name}",
-    points: new List<PointStruct>
-    {
-        new PointStruct
-        {
-            Id = 1,
-            Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
-            Payload = { ["city"] = "Berlin", ["price"] = 1.99 }
-        },
-        new PointStruct
-        {
-            Id = 2,
-            Vectors = new[] { 0.19f, 0.81f, 0.75f, 0.11f },
-            Payload = { ["city"] = new[] { "Berlin", "London" } }
-        },
-        new PointStruct
-        {
-            Id = 3,
-            Vectors = new[] { 0.36f, 0.55f, 0.47f, 0.94f },
-            Payload =
-            {
-                ["city"] = new[] { "Berlin", "Moscow" },
-                ["price"] = new Value
-                {
-                    ListValue = new ListValue { Values = { new Value[] { 1.99, 2.99 } } }
-                }
-            }
-        }
-    }
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-    CollectionName: "{collection_name}",
-    Points: []*qdrant.PointStruct{
-        {
-            Id:      qdrant.NewIDNum(1),
-            Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
-            Payload: qdrant.NewValueMap(map[string]any{
-                "city": "Berlin", "price": 1.99}),
-        },
-        {
-            Id:      qdrant.NewIDNum(2),
-            Vectors: qdrant.NewVectors(0.19, 0.81, 0.75, 0.11),
-            Payload: qdrant.NewValueMap(map[string]any{
-                "city": []any{"Berlin", "London"}}),
-        },
-        {
-            Id:      qdrant.NewIDNum(3),
-            Vectors: qdrant.NewVectors(0.36, 0.55, 0.47, 0.94),
-            Payload: qdrant.NewValueMap(map[string]any{
-                "city":  []any{"Berlin", "London"},
-                "price": []any{1.99, 2.99}}),
-        },
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/with-payload/" >}}
 
 ## Update payload
 
@@ -454,256 +211,12 @@ Set only the given payload values on a point.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/set-payload)):
 
-```http
-POST /collections/{collection_name}/points/payload
-{
-    "payload": {
-        "property1": "string",
-        "property2": "string"
-    },
-    "points": [
-        0, 3, 100
-    ]
-}
-```
-
-```python
-client.set_payload(
-    collection_name="{collection_name}",
-    payload={
-        "property1": "string",
-        "property2": "string",
-    },
-    points=[0, 3, 10],
-)
-```
-
-```typescript
-client.setPayload("{collection_name}", {
-  payload: {
-    property1: "string",
-    property2: "string",
-  },
-  points: [0, 3, 10],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    PointsIdsList, SetPayloadPointsBuilder,
-};
-use qdrant_client::Payload,;
-use serde_json::json;
-
-client
-    .set_payload(
-        SetPayloadPointsBuilder::new(
-            "{collection_name}",
-            Payload::try_from(json!({
-                "property1": "string",
-                "property2": "string",
-            }))
-            .unwrap(),
-        )
-        .points_selector(PointsIdsList {
-            ids: vec![0.into(), 3.into(), 10.into()],
-        })
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-
-client
-    .setPayloadAsync(
-        "{collection_name}",
-        Map.of("property1", value("string"), "property2", value("string")),
-        List.of(id(0), id(3), id(10)),
-        true,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.SetPayloadAsync(
-    collectionName: "{collection_name}",
-    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
-    ids: new ulong[] { 0, 3, 10 }
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.SetPayload(context.Background(), &qdrant.SetPayloadPoints{
-    CollectionName: "{collection_name}",
-    Payload: qdrant.NewValueMap(
-        map[string]any{"property1": "string", "property2": "string"}),
-    PointsSelector: qdrant.NewPointsSelector(
-        qdrant.NewIDNum(0),
-        qdrant.NewIDNum(3)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/set-payload/by-point-id/" >}}
 
 You don't need to know the ids of the points you want to modify. The alternative
 is to use filters.
 
-```http
-POST /collections/{collection_name}/points/payload
-{
-    "payload": {
-        "property1": "string",
-        "property2": "string"
-    },
-    "filter": {
-        "must": [
-            {
-                "key": "color",
-                "match": {
-                    "value": "red"
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.set_payload(
-    collection_name="{collection_name}",
-    payload={
-        "property1": "string",
-        "property2": "string",
-    },
-    points=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="color",
-                match=models.MatchValue(value="red"),
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.setPayload("{collection_name}", {
-  payload: {
-    property1: "string",
-    property2: "string",
-  },
-  filter: {
-    must: [
-      {
-        key: "color",
-        match: {
-          value: "red",
-        },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, SetPayloadPointsBuilder};
-use qdrant_client::Payload;
-use serde_json::json;
-
-client
-    .set_payload(
-        SetPayloadPointsBuilder::new(
-            "{collection_name}",
-            Payload::try_from(json!({
-                "property1": "string",
-                "property2": "string",
-            }))
-            .unwrap(),
-        )
-        .points_selector(Filter::must([Condition::matches(
-            "color",
-            "red".to_string(),
-        )]))
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.Map;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.ValueFactory.value;
-
-client
-    .setPayloadAsync(
-        "{collection_name}",
-        Map.of("property1", value("string"), "property2", value("string")),
-        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
-        true,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.SetPayloadAsync(
-    collectionName: "{collection_name}",
-    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
-    filter: MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.SetPayload(context.Background(), &qdrant.SetPayloadPoints{
-    CollectionName: "{collection_name}",
-    Payload: qdrant.NewValueMap(
-        map[string]any{"property1": "string", "property2": "string"}),
-    PointsSelector: qdrant.NewPointsSelectorFilter(&qdrant.Filter{
-        Must: []*qdrant.Condition{
-            qdrant.NewMatch("color", "red"),
-        },
-    }),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/set-payload/by-filter/" >}}
 
 _Available as of v1.8.0_
 
@@ -724,16 +237,7 @@ For instance, given the following payload JSON object on a point:
 
 You can modify the `nested_property` of `property1` with the following request:
 
-```http
-POST /collections/{collection_name}/points/payload
-{
-    "payload": {
-        "nested_property": "qux",
-    },
-    "key": "property1",
-    "points": [1]
-}
-```
+{{< code-snippet path="/documentation/headless/snippets/set-payload/by-nested-key/" >}}
 
 Resulting in the following payload:
 
@@ -754,114 +258,7 @@ Fully replace any existing payload with the given one.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/overwrite-payload)):
 
-```http
-PUT /collections/{collection_name}/points/payload
-{
-    "payload": {
-        "property1": "string",
-        "property2": "string"
-    },
-    "points": [
-        0, 3, 100
-    ]
-}
-```
-
-```python
-client.overwrite_payload(
-    collection_name="{collection_name}",
-    payload={
-        "property1": "string",
-        "property2": "string",
-    },
-    points=[0, 3, 10],
-)
-```
-
-```typescript
-client.overwritePayload("{collection_name}", {
-  payload: {
-    property1: "string",
-    property2: "string",
-  },
-  points: [0, 3, 10],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointsIdsList, SetPayloadPointsBuilder};
-use qdrant_client::Payload;
-use serde_json::json;
-
-client
-    .overwrite_payload(
-        SetPayloadPointsBuilder::new(
-            "{collection_name}",
-            Payload::try_from(json!({
-                "property1": "string",
-                "property2": "string",
-            }))
-            .unwrap(),
-        )
-        .points_selector(PointsIdsList {
-            ids: vec![0.into(), 3.into(), 10.into()],
-        })
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-
-client
-    .overwritePayloadAsync(
-        "{collection_name}",
-        Map.of("property1", value("string"), "property2", value("string")),
-        List.of(id(0), id(3), id(10)),
-        true,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.OverwritePayloadAsync(
-    collectionName: "{collection_name}",
-    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
-    ids: new ulong[] { 0, 3, 10 }
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.OverwritePayload(context.Background(), &qdrant.SetPayloadPoints{
-    CollectionName: "{collection_name}",
-    Payload: qdrant.NewValueMap(
-        map[string]any{"property1": "string", "property2": "string"}),
-    PointsSelector: qdrant.NewPointsSelector(
-        qdrant.NewIDNum(0),
-        qdrant.NewIDNum(3)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/overwrite-payload/by-point-id/" >}}
 
 Like [set payload](#set-payload), you don't need to know the ids of the points
 you want to modify. The alternative is to use filters.
@@ -872,77 +269,7 @@ This method removes all payload keys from specified points
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/clear-payload)):
 
-```http
-POST /collections/{collection_name}/points/payload/clear
-{
-    "points": [0, 3, 100]
-}
-```
-
-```python
-client.clear_payload(
-    collection_name="{collection_name}",
-    points_selector=[0, 3, 100],
-)
-```
-
-```typescript
-client.clearPayload("{collection_name}", {
-  points: [0, 3, 100],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{ClearPayloadPointsBuilder, PointsIdsList};
-
-client
-    .clear_payload(
-        ClearPayloadPointsBuilder::new("{collection_name}")
-            .points(PointsIdsList {
-                ids: vec![0.into(), 3.into(), 10.into()],
-            })
-            .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-
-client
-    .clearPayloadAsync("{collection_name}", List.of(id(0), id(3), id(100)), true, null, null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ClearPayloadAsync(collectionName: "{collection_name}", ids: new ulong[] { 0, 3, 100 });
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.ClearPayload(context.Background(), &qdrant.ClearPayloadPoints{
-    CollectionName: "{collection_name}",
-    Points: qdrant.NewPointsSelector(
-        qdrant.NewIDNum(0),
-        qdrant.NewIDNum(3)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/clear-payload/simple/" >}}
 
 <aside role="status">
 You can also use <code>models.FilterSelector</code> to remove the points matching given filter criteria, instead of providing the ids.
@@ -954,214 +281,11 @@ Delete specific payload keys from points.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/delete-payload)):
 
-```http
-POST /collections/{collection_name}/points/payload/delete
-{
-    "keys": ["color", "price"],
-    "points": [0, 3, 100]
-}
-```
-
-```python
-client.delete_payload(
-    collection_name="{collection_name}",
-    keys=["color", "price"],
-    points=[0, 3, 100],
-)
-```
-
-```typescript
-client.deletePayload("{collection_name}", {
-  keys: ["color", "price"],
-  points: [0, 3, 100],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{DeletePayloadPointsBuilder, PointsIdsList};
-
-client
-    .delete_payload(
-        DeletePayloadPointsBuilder::new(
-            "{collection_name}",
-            vec!["color".to_string(), "price".to_string()],
-        )
-        .points_selector(PointsIdsList {
-            ids: vec![0.into(), 3.into(), 10.into()],
-        })
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-
-client
-    .deletePayloadAsync(
-        "{collection_name}",
-        List.of("color", "price"),
-        List.of(id(0), id(3), id(100)),
-        true,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeletePayloadAsync(
-    collectionName: "{collection_name}",
-    keys: ["color", "price"],
-    ids: new ulong[] { 0, 3, 100 }
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.DeletePayload(context.Background(), &qdrant.DeletePayloadPoints{
-    CollectionName: "{collection_name}",
-    Keys:           []string{"color", "price"},
-    PointsSelector: qdrant.NewPointsSelector(
-        qdrant.NewIDNum(0),
-        qdrant.NewIDNum(3)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-payload/by-point-id/" >}}
 
 Alternatively, you can use filters to delete payload keys from the points.
 
-```http
-POST /collections/{collection_name}/points/payload/delete
-{
-    "keys": ["color", "price"],
-    "filter": {
-        "must": [
-            {
-                "key": "color",
-                "match": {
-                    "value": "red"
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.delete_payload(
-    collection_name="{collection_name}",
-    keys=["color", "price"],
-    points=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="color",
-                match=models.MatchValue(value="red"),
-            ),
-        ],
-    ),
-)
-```
-
-```typescript
-client.deletePayload("{collection_name}", {
-  keys: ["color", "price"],
-  filter: {
-    must: [
-      {
-        key: "color",
-        match: {
-          value: "red",
-        },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, DeletePayloadPointsBuilder, Filter};
-
-client
-    .delete_payload(
-        DeletePayloadPointsBuilder::new(
-            "{collection_name}",
-            vec!["color".to_string(), "price".to_string()],
-        )
-        .points_selector(Filter::must([Condition::matches(
-            "color",
-            "red".to_string(),
-        )]))
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-client
-    .deletePayloadAsync(
-        "{collection_name}",
-        List.of("color", "price"),
-        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
-        true,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeletePayloadAsync(
-    collectionName: "{collection_name}",
-    keys: ["color", "price"],
-    filter: MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.DeletePayload(context.Background(), &qdrant.DeletePayloadPoints{
-    CollectionName: "{collection_name}",
-    Keys:           []string{"color", "price"},
-    PointsSelector: qdrant.NewPointsSelectorFilter(
-        &qdrant.Filter{
-            Must: []*qdrant.Condition{qdrant.NewMatch("color", "red")},
-        },
-    ),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-payload/by-filter/" >}}
 
 ## Payload indexing
 
@@ -1178,86 +302,7 @@ To create index for the field, you can use the following:
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/indexes/create-field-index))
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "name_of_the_field_to_index",
-    "field_schema": "keyword"
-}
-```
-
-```python
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="name_of_the_field_to_index",
-    field_schema="keyword",
-)
-```
-
-```typescript
-client.createPayloadIndex("{collection_name}", {
-  field_name: "name_of_the_field_to_index",
-  field_schema: "keyword",
-});
-```
-
-```rust
-use qdrant_client::qdrant::{CreateFieldIndexCollectionBuilder, FieldType};
-
-client
-    .create_field_index(
-        CreateFieldIndexCollectionBuilder::new(
-            "{collection_name}",
-            "name_of_the_field_to_index",
-            FieldType::Keyword,
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-
-client.createPayloadIndexAsync(
-    "{collection_name}",
-    "name_of_the_field_to_index",
-    PayloadSchemaType.Keyword,
-    null,
-    true,
-    null,
-    null);
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
-    collectionName: "{collection_name}",
-    fieldName: "name_of_the_field_to_index"
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-    CollectionName: "{collection_name}",
-    FieldName:      "name_of_the_field_to_index",
-    FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/simple-keyword/" >}}
 
 The index usage flag is displayed in the payload schema with the [collection info API](https://api.qdrant.tech/api-reference/collections/get-collection).
 
@@ -1297,125 +342,7 @@ To get the facet counts for a field, you can use the following:
 
 REST API ([Facet](https://api.qdrant.tech/v-1-13-x/api-reference/points/facet))
 
-```http
-POST /collections/{collection_name}/facet
-{
-    "key": "size",
-    "filter": {
-      "must": {
-        "key": "color",
-        "match": { "value": "red" }
-      }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.facet(
-    collection_name="{collection_name}",
-    key="size",
-    facet_filter=models.Filter(must=[models.Match("color", "red")]),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.facet("{collection_name}", {
-    filter: {
-        must: [
-            {
-                key: "color",
-                match: {
-                    value: "red",
-                },
-            },
-        ],
-    },
-    key: "size",
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, FacetCountsBuilder, Filter};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .facet(
-         FacetCountsBuilder::new("{collection_name}", "size")
-             .limit(10)
-             .filter(Filter::must(vec![Condition::matches(
-                 "color",
-                 "red".to_string(),
-             )])),
-     )
-     .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import io.qdrant.client.grpc.Points;
-import io.qdrant.client.grpc.Filter;
-
-QdrantClient client = new QdrantClient(
-                QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .facetAsync(
-        Points.FacetCounts.newBuilder()
-            .setCollectionName(collection_name)
-            .setKey("size")
-            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-            .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.FacetAsync(
-    "{collection_name}",
-    key: "size",
-    filter: MatchKeyword("color", "red")
-);
-```
-
-```go
-import (
-    "context"
-
-    "github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-    Host: "localhost",
-    Port: 6334,
-})
-
-res, err := client.Facet(ctx, &qdrant.FacetCounts{
-    CollectionName: "{collection_name}",
-    Key:            "size",
-        Filter: &qdrant.Filter{
-        Must: []*qdrant.Condition{
-            qdrant.NewMatch("color", "red"),
-        },
-    },
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/facet-counts/simple-with-filter/" >}}
 
 The response will contain the counts for each unique value in the field:
 
@@ -1439,66 +366,4 @@ Only values with non-zero counts will be returned.
 
 By default, the way Qdrant the counts for each value is approximate to achieve fast results. This should accurate enough for most cases, but if you need to debug your storage, you can use the `exact` parameter to get exact counts.
 
-```http
-POST /collections/{collection_name}/facet
-{
-    "key": "size",
-    "exact": true
-}
-```
-
-```python
-client.facet(
-    collection_name="{collection_name}",
-    key="size",
-    exact=True,
-)
-```
-
-```typescript
-client.facet("{collection_name}", {
-    key: "size",
-    exact: true,
-});
-```
-
-```rust
-use qdrant_client::qdrant::FacetCountsBuilder;
-
-client
-    .facet(
-         FacetCountsBuilder::new("{collection_name}", "size")
-             .limit(10)
-             .exact(true),
-     )
-     .await?;
-```
-
-```java
- client
-      .facetAsync(
-          Points.FacetCounts.newBuilder()
-              .setCollectionName(collection_name)
-              .setKey("foo")
-              .setExact(true)
-              .build())
-      .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-await client.FacetAsync(
-    "{collection_name}",
-    key: "size",
-    exact: true,
-);
-```
-
-```go
-res, err := client.Facet(ctx, &qdrant.FacetCounts{
-    CollectionName: "{collection_name}",
-    Key:            "key",
-    Exact:          true,
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/facet-counts/exact/" >}}
diff --git a/qdrant-landing/content/documentation/concepts/points.md b/qdrant-landing/content/documentation/concepts/points.md
old mode 100755
new mode 100644
index d9d53382c..ef23e9780
--- a/qdrant-landing/content/documentation/concepts/points.md
+++ b/qdrant-landing/content/documentation/concepts/points.md
@@ -45,284 +45,11 @@ Examples of UUID string representations:
 That means that in every request UUID string could be used instead of numerical id.
 Example:
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
-            "payload": {"color": "red"},
-            "vector": [0.9, 0.1, 0.1]
-        }
-    ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id="5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
-            payload={
-                "color": "red",
-            },
-            vector=[0.9, 0.1, 0.1],
-        ),
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
-      payload: {
-        color: "red",
-      },
-      vector: [0.9, 0.1, 0.1],
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![PointStruct::new(
-                "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
-                vec![0.9, 0.1, 0.1],
-                [("color", "Red".into())],
-            )],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-import static io.qdrant.client.VectorsFactory.vectors;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(UUID.fromString("5c56c793-69f3-4fbf-87e6-c4bf54c28c26")))
-                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
-                .putAllPayload(Map.of("color", value("Red")))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = Guid.Parse("5c56c793-69f3-4fbf-87e6-c4bf54c28c26"),
-			Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
-			Payload = { ["color"] = "Red" }
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id:      qdrant.NewID("5c56c793-69f3-4fbf-87e6-c4bf54c28c26"),
-			Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
-			Payload: qdrant.NewValueMap(map[string]any{"color": "Red"}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/uuid-one-point-simple/" >}}
 
 and
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "payload": {"color": "red"},
-            "vector": [0.9, 0.1, 0.1]
-        }
-    ]
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            payload={
-                "color": "red",
-            },
-            vector=[0.9, 0.1, 0.1],
-        ),
-    ],
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      payload: {
-        color: "red",
-      },
-      vector: [0.9, 0.1, 0.1],
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![PointStruct::new(
-                1,
-                vec![0.9, 0.1, 0.1],
-                [("color", "Red".into())],
-            )],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-import static io.qdrant.client.VectorsFactory.vectors;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
-                .putAllPayload(Map.of("color", value("Red")))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = 1,
-			Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
-			Payload = { ["color"] = "Red" }
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id:      qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
-			Payload: qdrant.NewValueMap(map[string]any{"color": "Red"}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/int-one-point-simple/" >}}
 
 are both possible.
 
@@ -356,254 +83,11 @@ Internally, these options do not differ and are made only for the convenience of
 
 Create points with batch:
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "batch": {
-        "ids": [1, 2, 3],
-        "payloads": [
-            {"color": "red"},
-            {"color": "green"},
-            {"color": "blue"}
-        ],
-        "vectors": [
-            [0.9, 0.1, 0.1],
-            [0.1, 0.9, 0.1],
-            [0.1, 0.1, 0.9]
-        ]
-    }
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=models.Batch(
-        ids=[1, 2, 3],
-        payloads=[
-            {"color": "red"},
-            {"color": "green"},
-            {"color": "blue"},
-        ],
-        vectors=[
-            [0.9, 0.1, 0.1],
-            [0.1, 0.9, 0.1],
-            [0.1, 0.1, 0.9],
-        ],
-    ),
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-  batch: {
-    ids: [1, 2, 3],
-    payloads: [{ color: "red" }, { color: "green" }, { color: "blue" }],
-    vectors: [
-      [0.9, 0.1, 0.1],
-      [0.1, 0.9, 0.1],
-      [0.1, 0.1, 0.9],
-    ],
-  },
-});
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/batch-simple/" >}}
 
 or record-oriented equivalent:
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "payload": {"color": "red"},
-            "vector": [0.9, 0.1, 0.1]
-        },
-        {
-            "id": 2,
-            "payload": {"color": "green"},
-            "vector": [0.1, 0.9, 0.1]
-        },
-        {
-            "id": 3,
-            "payload": {"color": "blue"},
-            "vector": [0.1, 0.1, 0.9]
-        }
-    ]
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            payload={
-                "color": "red",
-            },
-            vector=[0.9, 0.1, 0.1],
-        ),
-        models.PointStruct(
-            id=2,
-            payload={
-                "color": "green",
-            },
-            vector=[0.1, 0.9, 0.1],
-        ),
-        models.PointStruct(
-            id=3,
-            payload={
-                "color": "blue",
-            },
-            vector=[0.1, 0.1, 0.9],
-        ),
-    ],
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      payload: { color: "red" },
-      vector: [0.9, 0.1, 0.1],
-    },
-    {
-      id: 2,
-      payload: { color: "green" },
-      vector: [0.1, 0.9, 0.1],
-    },
-    {
-      id: 3,
-      payload: { color: "blue" },
-      vector: [0.1, 0.1, 0.9],
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![
-                PointStruct::new(1, vec![0.9, 0.1, 0.1], [("city", "red".into())]),
-                PointStruct::new(2, vec![0.1, 0.9, 0.1], [("city", "green".into())]),
-                PointStruct::new(3, vec![0.1, 0.1, 0.9], [("city", "blue".into())]),
-            ],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-import static io.qdrant.client.VectorsFactory.vectors;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(vectors(0.9f, 0.1f, 0.1f))
-                .putAllPayload(Map.of("color", value("red")))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(2))
-                .setVectors(vectors(0.1f, 0.9f, 0.1f))
-                .putAllPayload(Map.of("color", value("green")))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(3))
-                .setVectors(vectors(0.1f, 0.1f, 0.9f))
-                .putAllPayload(Map.of("color", value("blue")))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = 1,
-			Vectors = new[] { 0.9f, 0.1f, 0.1f },
-			Payload = { ["color"] = "red" }
-		},
-		new()
-		{
-			Id = 2,
-			Vectors = new[] { 0.1f, 0.9f, 0.1f },
-			Payload = { ["color"] = "green" }
-		},
-		new()
-		{
-			Id = 3,
-			Vectors = new[] { 0.1f, 0.1f, 0.9f },
-			Payload = { ["color"] = "blue" }
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id:      qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectors(0.9, 0.1, 0.1),
-			Payload: qdrant.NewValueMap(map[string]any{"color": "red"}),
-		},
-		{
-			Id:      qdrant.NewIDNum(2),
-			Vectors: qdrant.NewVectors(0.1, 0.9, 0.1),
-			Payload: qdrant.NewValueMap(map[string]any{"color": "green"}),
-		},
-		{
-			Id:      qdrant.NewIDNum(3),
-			Vectors: qdrant.NewVectors(0.1, 0.1, 0.9),
-			Payload: qdrant.NewValueMap(map[string]any{"color": "blue"}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/list-of-points-simple/" >}}
 
 The Python client has additional features for loading points, which include:
 
@@ -680,212 +164,7 @@ Even with such a system, Qdrant ensures data consistency.
 
 If the collection was created with multiple vectors, each vector data can be provided using the vector's name:
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": {
-                "image": [0.9, 0.1, 0.1, 0.2],
-                "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2]
-            }
-        },
-        {
-            "id": 2,
-            "vector": {
-                "image": [0.2, 0.1, 0.3, 0.9],
-                "text": [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9]
-            }
-        }
-    ]
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            vector={
-                "image": [0.9, 0.1, 0.1, 0.2],
-                "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
-            },
-        ),
-        models.PointStruct(
-            id=2,
-            vector={
-                "image": [0.2, 0.1, 0.3, 0.9],
-                "text": [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
-            },
-        ),
-    ],
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: {
-        image: [0.9, 0.1, 0.1, 0.2],
-        text: [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
-      },
-    },
-    {
-      id: 2,
-      vector: {
-        image: [0.2, 0.1, 0.3, 0.9],
-        text: [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
-      },
-    },
-  ],
-});
-```
-
-```rust
-use std::collections::HashMap;
-
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-use qdrant_client::Payload;
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![
-                PointStruct::new(
-                    1,
-                    HashMap::from([
-                        ("image".to_string(), vec![0.9, 0.1, 0.1, 0.2]),
-                        (
-                            "text".to_string(),
-                            vec![0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
-                        ),
-                    ]),
-                    Payload::default(),
-                ),
-                PointStruct::new(
-                    2,
-                    HashMap::from([
-                        ("image".to_string(), vec![0.2, 0.1, 0.3, 0.9]),
-                        (
-                            "text".to_string(),
-                            vec![0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
-                        ),
-                    ]),
-                    Payload::default(),
-                ),
-            ],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorFactory.vector;
-import static io.qdrant.client.VectorsFactory.namedVectors;
-
-import io.qdrant.client.grpc.Points.PointStruct;
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(
-                    namedVectors(
-                        Map.of(
-                            "image",
-                            vector(List.of(0.9f, 0.1f, 0.1f, 0.2f)),
-                            "text",
-                            vector(List.of(0.4f, 0.7f, 0.1f, 0.8f, 0.1f, 0.1f, 0.9f, 0.2f)))))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(2))
-                .setVectors(
-                    namedVectors(
-                        Map.of(
-                            "image",
-                            List.of(0.2f, 0.1f, 0.3f, 0.9f),
-                            "text",
-                            List.of(0.5f, 0.2f, 0.7f, 0.4f, 0.7f, 0.2f, 0.3f, 0.9f))))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = 1,
-			Vectors = new Dictionary<string, float[]>
-			{
-				["image"] = [0.9f, 0.1f, 0.1f, 0.2f],
-				["text"] = [0.4f, 0.7f, 0.1f, 0.8f, 0.1f, 0.1f, 0.9f, 0.2f]
-			}
-		},
-		new()
-		{
-			Id = 2,
-			Vectors = new Dictionary<string, float[]>
-			{
-				["image"] = [0.2f, 0.1f, 0.3f, 0.9f],
-				["text"] = [0.5f, 0.2f, 0.7f, 0.4f, 0.7f, 0.2f, 0.3f, 0.9f]
-			}
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"image": qdrant.NewVector(0.9, 0.1, 0.1, 0.2),
-				"text":  qdrant.NewVector(0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2),
-			}),
-		},
-		{
-			Id: qdrant.NewIDNum(2),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"image": qdrant.NewVector(0.2, 0.1, 0.3, 0.9),
-				"text":  qdrant.NewVector(0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9),
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/with-multiple-vectors/" >}}
 
 _Available as of v1.2.0_
 
@@ -936,220 +215,7 @@ If the `indices` are not sorted, Qdrant will sort them internally so you may not
 
 Sparse vectors must be named and can be uploaded in the same way as dense vectors.
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": {
-                "text": {
-                    "indices": [6, 7],
-                    "values": [1.0, 2.0]
-                }
-            }
-        },
-        {
-            "id": 2,
-            "vector": {
-                "text": {
-                    "indices": [1, 1, 2, 3, 4, 5],
-                    "values": [0.1, 0.2, 0.3, 0.4, 0.5]
-                }
-            }
-        }
-    ]
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            vector={
-                "text": models.SparseVector(
-                    indices=[6, 7],
-                    values=[1.0, 2.0],
-                )
-            },
-        ),
-        models.PointStruct(
-            id=2,
-            vector={
-                "text": models.SparseVector(
-                    indices=[1, 2, 3, 4, 5],
-                    values=[0.1, 0.2, 0.3, 0.4, 0.5],
-                )
-            },
-        ),
-    ],
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: {
-        text: {
-          indices: [6, 7],
-          values: [1.0, 2.0],
-        },
-      },
-    },
-    {
-      id: 2,
-      vector: {
-        text: {
-          indices: [1, 2, 3, 4, 5],
-          values: [0.1, 0.2, 0.3, 0.4, 0.5],
-        },
-      },
-    },
-  ],
-});
-```
-
-```rust
-use std::collections::HashMap;
-
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder, Vector};
-use qdrant_client::Payload;
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![
-                PointStruct::new(
-                    1,
-                    HashMap::from([("text".to_string(), vec![(6, 1.0), (7, 2.0)])]),
-                    Payload::default(),
-                ),
-                PointStruct::new(
-                    2,
-                    HashMap::from([(
-                        "text".to_string(),
-                        vec![(1, 0.1), (2, 0.2), (3, 0.3), (4, 0.4), (5, 0.5)],
-                    )]),
-                    Payload::default(),
-                ),
-            ],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorFactory.vector;
-
-import io.qdrant.client.grpc.Points.NamedVectors;
-import io.qdrant.client.grpc.Points.PointStruct;
-import io.qdrant.client.grpc.Points.Vectors;
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(
-                    Vectors.newBuilder()
-                        .setVectors(
-                            NamedVectors.newBuilder()
-                                .putAllVectors(
-                                    Map.of(
-                                        "text", vector(List.of(1.0f, 2.0f), List.of(6, 7))))
-                                .build())
-                        .build())
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(2))
-                .setVectors(
-                    Vectors.newBuilder()
-                        .setVectors(
-                            NamedVectors.newBuilder()
-                                .putAllVectors(
-                                    Map.of(
-                                        "text",
-                                        vector(
-                                            List.of(0.1f, 0.2f, 0.3f, 0.4f, 0.5f),
-                                            List.of(1, 2, 3, 4, 5))))
-                                .build())
-                        .build())
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = 1,
-			Vectors = new Dictionary<string, Vector> { ["text"] = ([1.0f, 2.0f], [6, 7]) }
-		},
-		new()
-		{
-			Id = 2,
-			Vectors = new Dictionary<string, Vector>
-			{
-				["text"] = ([0.1f, 0.2f, 0.3f, 0.4f, 0.5f], [1, 2, 3, 4, 5])
-			}
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"text": qdrant.NewVectorSparse(
-					[]uint32{6, 7},
-					[]float32{1.0, 2.0}),
-			}),
-		},
-		{
-			Id: qdrant.NewIDNum(2),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"text": qdrant.NewVectorSparse(
-					[]uint32{1, 2, 3, 4, 5},
-					[]float32{0.1, 0.2, 0.3, 0.4, 0.5}),
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/sparse-vectors/" >}}
 
 ## Modify points
 
@@ -1165,176 +231,7 @@ vectors are kept unchanged. All given points must exist.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/update-vectors)):
 
-```http
-PUT /collections/{collection_name}/points/vectors
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": {
-                "image": [0.1, 0.2, 0.3, 0.4]
-            }
-        },
-        {
-            "id": 2,
-            "vector": {
-                "text": [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2]
-            }
-        }
-    ]
-}
-```
-
-```python
-client.update_vectors(
-    collection_name="{collection_name}",
-    points=[
-        models.PointVectors(
-            id=1,
-            vector={
-                "image": [0.1, 0.2, 0.3, 0.4],
-            },
-        ),
-        models.PointVectors(
-            id=2,
-            vector={
-                "text": [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
-            },
-        ),
-    ],
-)
-```
-
-```typescript
-client.updateVectors("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: {
-        image: [0.1, 0.2, 0.3, 0.4],
-      },
-    },
-    {
-      id: 2,
-      vector: {
-        text: [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
-      },
-    },
-  ],
-});
-```
-
-```rust
-use std::collections::HashMap;
-
-use qdrant_client::qdrant::{
-    PointVectors, UpdatePointVectorsBuilder,
-};
-
-client
-    .update_vectors(
-        UpdatePointVectorsBuilder::new(
-            "{collection_name}",
-            vec![
-                PointVectors {
-                    id: Some(1.into()),
-                    vectors: Some(
-                        HashMap::from([("image".to_string(), vec![0.1, 0.2, 0.3, 0.4])]).into(),
-                    ),
-                },
-                PointVectors {
-                    id: Some(2.into()),
-                    vectors: Some(
-                        HashMap::from([(
-                            "text".to_string(),
-                            vec![0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
-                        )])
-                        .into(),
-                    ),
-                },
-            ],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorFactory.vector;
-import static io.qdrant.client.VectorsFactory.namedVectors;
-
-client
-    .updateVectorsAsync(
-        "{collection_name}",
-        List.of(
-            PointVectors.newBuilder()
-                .setId(id(1))
-                .setVectors(namedVectors(Map.of("image", vector(List.of(0.1f, 0.2f, 0.3f, 0.4f)))))
-                .build(),
-            PointVectors.newBuilder()
-                .setId(id(2))
-                .setVectors(
-                    namedVectors(
-                        Map.of(
-                            "text", vector(List.of(0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f)))))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpdateVectorsAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointVectors>
-	{
-		new() { Id = 1, Vectors = ("image", new float[] { 0.1f, 0.2f, 0.3f, 0.4f }) },
-		new()
-		{
-			Id = 2,
-			Vectors = ("text", new float[] { 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f })
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.UpdateVectors(context.Background(), &qdrant.UpdatePointVectors{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointVectors{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"image": qdrant.NewVector(0.1, 0.2, 0.3, 0.4),
-			}),
-		},
-		{
-			Id: qdrant.NewIDNum(2),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"text": qdrant.NewVector(0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2),
-			}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/update-vectors/simple/" >}}
 
 To update points and replace all of its vectors, see [uploading
 points](#upload-points).
@@ -1348,77 +245,7 @@ vectors are kept unchanged. Points are never deleted.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/delete-vectors)):
 
-```http
-POST /collections/{collection_name}/points/vectors/delete
-{
-    "points": [0, 3, 100],
-    "vectors": ["text", "image"]
-}
-```
-
-```python
-client.delete_vectors(
-    collection_name="{collection_name}",
-    points=[0, 3, 100],
-    vectors=["text", "image"],
-)
-```
-
-```typescript
-client.deleteVectors("{collection_name}", {
-  points: [0, 3, 10],
-  vector: ["text", "image"],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    DeletePointVectorsBuilder, PointsIdsList,
-};
-
-client
-    .delete_vectors(
-        DeletePointVectorsBuilder::new("{collection_name}")
-            .points_selector(PointsIdsList {
-                ids: vec![0.into(), 3.into(), 10.into()],
-            })
-            .vectors(vec!["text".into(), "image".into()])
-            .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-
-client
-    .deleteVectorsAsync(
-        "{collection_name}", List.of("text", "image"), List.of(id(0), id(3), id(10)))
-    .get();
-```
-
-```csharp
-await client.DeleteVectorsAsync("{collection_name}", ["text", "image"], [0, 3, 10]);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client.DeleteVectors(context.Background(), &qdrant.DeletePointVectors{
-	CollectionName: "{collection_name}",
-	PointsSelector: qdrant.NewPointsSelector(
-		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(10)),
-	Vectors: &qdrant.VectorsSelector{
-		Names: []string{"text", "image"},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-vectors/simple/" >}}
 
 To delete entire points, see [deleting points](#delete-points).
 
@@ -1430,186 +257,11 @@ Learn how to modify the payload of a point in the [Payload](/documentation/conce
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/delete-points)):
 
-```http
-POST /collections/{collection_name}/points/delete
-{
-    "points": [0, 3, 100]
-}
-```
-
-```python
-client.delete(
-    collection_name="{collection_name}",
-    points_selector=models.PointIdsList(
-        points=[0, 3, 100],
-    ),
-)
-```
-
-```typescript
-client.delete("{collection_name}", {
-  points: [0, 3, 100],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{DeletePointsBuilder, PointsIdsList};
-
-client
-    .delete_points(
-        DeletePointsBuilder::new("{collection_name}")
-            .points(PointsIdsList {
-                ids: vec![0.into(), 3.into(), 100.into()],
-            })
-            .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-
-client.deleteAsync("{collection_name}", List.of(id(0), id(3), id(100)));
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeleteAsync(collectionName: "{collection_name}", ids: [0, 3, 100]);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Delete(context.Background(), &qdrant.DeletePoints{
-	CollectionName: "{collection_name}",
-	Points: qdrant.NewPointsSelector(
-		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(100),
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-points/simple/" >}}
 
 Alternative way to specify which points to remove is to use filter.
 
-```http
-POST /collections/{collection_name}/points/delete
-{
-    "filter": {
-        "must": [
-            {
-                "key": "color",
-                "match": {
-                    "value": "red"
-                }
-            }
-        ]
-    }
-}
-```
-
-```python
-client.delete(
-    collection_name="{collection_name}",
-    points_selector=models.FilterSelector(
-        filter=models.Filter(
-            must=[
-                models.FieldCondition(
-                    key="color",
-                    match=models.MatchValue(value="red"),
-                ),
-            ],
-        )
-    ),
-)
-```
-
-```typescript
-client.delete("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "color",
-        match: {
-          value: "red",
-        },
-      },
-    ],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, DeletePointsBuilder, Filter};
-
-client
-    .delete_points(
-        DeletePointsBuilder::new("{collection_name}")
-            .points(Filter::must([Condition::matches(
-                "color",
-                "red".to_string(),
-            )]))
-            .wait(true),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-
-client
-    .deleteAsync(
-        "{collection_name}",
-        Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeleteAsync(collectionName: "{collection_name}", filter: MatchKeyword("color", "red"));
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Delete(context.Background(), &qdrant.DeletePoints{
-	CollectionName: "{collection_name}",
-	Points: qdrant.NewPointsSelectorFilter(
-		&qdrant.Filter{
-			Must: []*qdrant.Condition{
-				qdrant.NewMatch("color", "red"),
-			},
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/delete-points/by-filter/" >}}
 
 This example removes all points with `{ "color": "red" }` from the collection.
 
@@ -1619,79 +271,7 @@ There is a method for retrieving points by their ids.
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/get-points)):
 
-```http
-POST /collections/{collection_name}/points
-{
-    "ids": [0, 3, 100]
-}
-```
-
-```python
-client.retrieve(
-    collection_name="{collection_name}",
-    ids=[0, 3, 100],
-)
-```
-
-```typescript
-client.retrieve("{collection_name}", {
-  ids: [0, 3, 100],
-});
-```
-
-```rust
-use qdrant_client::qdrant::GetPointsBuilder;
-
-client
-    .get_points(GetPointsBuilder::new(
-        "{collection_name}",
-        vec![0.into(), 30.into(), 100.into()],
-    ))
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-
-client
-    .retrieveAsync("{collection_name}", List.of(id(0), id(30), id(100)), false, false, null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.RetrieveAsync(
-	collectionName: "{collection_name}",
-	ids: [0, 30, 100],
-	withPayload: false,
-	withVectors: false
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Get(context.Background(), &qdrant.GetPoints{
-	CollectionName: "{collection_name}",
-	Ids: []*qdrant.PointId{
-		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(100),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/retrieve-points/simple/" >}}
 
 This method has additional parameters `with_vectors` and `with_payload`.
 Using these parameters, you can select parts of the point you want as a result.
@@ -1701,9 +281,7 @@ The single point can also be retrieved via the API:
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/points/get-point)):
 
-```http
-GET /collections/{collection_name}/points/{point_id}
-```
+{{< code-snippet path="/documentation/headless/snippets/retrieve-points/single/" >}}
 
 ## Scroll points
 
@@ -1711,129 +289,7 @@ Sometimes it might be necessary to get all stored points without knowing ids, or
 
 REST API ([Schema](https://api.qdrant.tech/master/api-reference/points/scroll-points)):
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "filter": {
-        "must": [
-            {
-                "key": "color",
-                "match": {
-                    "value": "red"
-                }
-            }
-        ]
-    },
-    "limit": 1,
-    "with_payload": true,
-    "with_vector": false
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    scroll_filter=models.Filter(
-        must=[
-            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
-        ]
-    ),
-    limit=1,
-    with_payload=True,
-    with_vectors=False,
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "color",
-        match: {
-          value: "red",
-        },
-      },
-    ],
-  },
-  limit: 1,
-  with_payload: true,
-  with_vector: false,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}")
-            .filter(Filter::must([Condition::matches(
-                "color",
-                "red".to_string(),
-            )]))
-            .limit(1)
-            .with_payload(true)
-            .with_vectors(false),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.WithPayloadSelectorFactory.enable;
-
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client
-    .scrollAsync(
-        ScrollPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
-            .setLimit(1)
-            .setWithPayload(enable(true))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ScrollAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("color", "red"),
-	limit: 1,
-	payloadSelector: true
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-	Limit:       qdrant.PtrOf(uint32(1)),
-	WithPayload: qdrant.NewWithPayload(true),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-filter-and-params/" >}}
 
 Returns all point with `color` = `red`.
 
@@ -1869,146 +325,11 @@ When using the [`scroll`](#scroll-points) API, you can sort the results by paylo
 
 <aside role="status">Without an appropriate index, payload-based ordering would create too much load on the system for each request. Qdrant therefore requires a payload index which supports <a href=/documentation/concepts/indexing/#payload-index target="_blank">Range filtering conditions</a> on the field used for <code>order_by</code></aside>
 
-```http
-POST /collections/{collection_name}/points/scroll
-{
-    "limit": 15,
-    "order_by": "timestamp", // <-- this!
-}
-```
-
-```python
-client.scroll(
-    collection_name="{collection_name}",
-    limit=15,
-    order_by="timestamp", # <-- this!
-)
-```
-
-```typescript
-client.scroll("{collection_name}", {
-  limit: 15,
-  order_by: "timestamp", // <-- this!
-});
-```
-
-```rust
-use qdrant_client::qdrant::{OrderByBuilder, ScrollPointsBuilder};
-
-client
-    .scroll(
-        ScrollPointsBuilder::new("{collection_name}")
-            .limit(15)
-            .order_by(OrderByBuilder::new("timestamp")),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.grpc.Points.OrderBy;
-import io.qdrant.client.grpc.Points.ScrollPoints;
-
-client.scrollAsync(ScrollPoints.newBuilder()
-  .setCollectionName("{collection_name}")
-  .setLimit(15)
-  .setOrderBy(OrderBy.newBuilder().setKey("timestamp").build())
-  .build()).get();
-```
-
-```csharp
-await client.ScrollAsync("{collection_name}", limit: 15, orderBy: "timestamp");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Scroll(context.Background(), &qdrant.ScrollPoints{
-	CollectionName: "{collection_name}",
-	Limit:          qdrant.PtrOf(uint32(15)),
-	OrderBy: &qdrant.OrderBy{
-		Key: "timestamp",
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-order-by-simple/" >}}
 
 You need to use the `order_by` `key` parameter to specify the payload key. Then you can add other fields to control the ordering, such as `direction` and `start_from`:
 
-```http
-"order_by": {
-    "key": "timestamp",
-    "direction": "desc" // default is "asc"
-    "start_from": 123, // start from this value
-}
-```
-
-```python
-order_by=models.OrderBy(
-    key="timestamp",
-    direction="desc",  # default is "asc"
-    start_from=123,  # start from this value
-)
-```
-
-```typescript
-order_by: {
-    key: "timestamp",
-    direction: "desc", // default is "asc"
-    start_from: 123, // start from this value
-}
-```
-
-```rust
-use qdrant_client::qdrant::{start_from::Value, Direction, OrderByBuilder};
-
-OrderByBuilder::new("timestamp")
-    .direction(Direction::Desc.into())
-    .start_from(Value::Integer(123))
-    .build();
-```
-
-```java
-import io.qdrant.client.grpc.Points.Direction;
-import io.qdrant.client.grpc.Points.OrderBy;
-import io.qdrant.client.grpc.Points.StartFrom;
-
-OrderBy.newBuilder()
-  .setKey("timestamp")
-  .setDirection(Direction.Desc)
-  .setStartFrom(StartFrom.newBuilder()
-    .setInteger(123)
-    .build())
-  .build();
-```
-
-```csharp
-using Qdrant.Client.Grpc;
-
-new OrderBy
-{
- Key = "timestamp",
- Direction = Direction.Desc,
- StartFrom = 123
-};
-```
-
-```go
-import "github.com/qdrant/go-client/qdrant"
-
-qdrant.OrderBy{
-	Key:       "timestamp",
-	Direction: qdrant.Direction_Desc.Enum(),
-	StartFrom: qdrant.NewStartFromInt(123),
-}
-```
+{{< code-snippet path="/documentation/headless/snippets/scroll-points/with-order-by-advanced/" >}}
 
 <aside role="alert">When you use the <code>order_by</code> parameter, pagination is disabled.</aside>
 
@@ -2028,113 +349,7 @@ Among others, for example, we can highlight the following scenarios:
 
 REST API ([Schema](https://api.qdrant.tech/master/api-reference/points/count-points)):
 
-```http
-POST /collections/{collection_name}/points/count
-{
-    "filter": {
-        "must": [
-            {
-                "key": "color",
-                "match": {
-                    "value": "red"
-                }
-            }
-        ]
-    },
-    "exact": true
-}
-```
-
-```python
-client.count(
-    collection_name="{collection_name}",
-    count_filter=models.Filter(
-        must=[
-            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
-        ]
-    ),
-    exact=True,
-)
-```
-
-```typescript
-client.count("{collection_name}", {
-  filter: {
-    must: [
-      {
-        key: "color",
-        match: {
-          value: "red",
-        },
-      },
-    ],
-  },
-  exact: true,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, CountPointsBuilder, Filter};
-
-client
-    .count(
-        CountPointsBuilder::new("{collection_name}")
-            .filter(Filter::must([Condition::matches(
-                "color",
-                "red".to_string(),
-            )]))
-            .exact(true),
-    )
-    .await?;
-```
-
-```java
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-import io.qdrant.client.grpc.Points.Filter;
-
-client
-    .countAsync(
-        "{collection_name}",
-        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
-        true)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CountAsync(
-	collectionName: "{collection_name}",
-	filter: MatchKeyword("color", "red"),
-	exact: true
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Count(context.Background(), &qdrant.CountPoints{
-	CollectionName: "midlib",
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("color", "red"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/count-points/with-filter-exact/" >}}
 
 Returns number of counts matching given filtering conditions:
 
@@ -2167,384 +382,7 @@ The following example snippet makes use of all operations.
 
 REST API ([Schema](https://api.qdrant.tech/master/api-reference/points/batch-update)):
 
-```http
-POST /collections/{collection_name}/points/batch
-{
-    "operations": [
-        {
-            "upsert": {
-                "points": [
-                    {
-                        "id": 1,
-                        "vector": [1.0, 2.0, 3.0, 4.0],
-                        "payload": {}
-                    }
-                ]
-            }
-        },
-        {
-            "update_vectors": {
-                "points": [
-                    {
-                        "id": 1,
-                        "vector": [1.0, 2.0, 3.0, 4.0]
-                    }
-                ]
-            }
-        },
-        {
-            "delete_vectors": {
-                "points": [1],
-                "vector": [""]
-            }
-        },
-        {
-            "overwrite_payload": {
-                "payload": {
-                    "test_payload": "1"
-                },
-                "points": [1]
-            }
-        },
-        {
-            "set_payload": {
-                "payload": {
-                    "test_payload_2": "2",
-                    "test_payload_3": "3"
-                },
-                "points": [1]
-            }
-        },
-        {
-            "delete_payload": {
-                "keys": ["test_payload_2"],
-                "points": [1]
-            }
-        },
-        {
-            "clear_payload": {
-                "points": [1]
-            }
-        },
-        {"delete": {"points": [1]}}
-    ]
-}
-```
-
-```python
-client.batch_update_points(
-    collection_name="{collection_name}",
-    update_operations=[
-        models.UpsertOperation(
-            upsert=models.PointsList(
-                points=[
-                    models.PointStruct(
-                        id=1,
-                        vector=[1.0, 2.0, 3.0, 4.0],
-                        payload={},
-                    ),
-                ]
-            )
-        ),
-        models.UpdateVectorsOperation(
-            update_vectors=models.UpdateVectors(
-                points=[
-                    models.PointVectors(
-                        id=1,
-                        vector=[1.0, 2.0, 3.0, 4.0],
-                    )
-                ]
-            )
-        ),
-        models.DeleteVectorsOperation(
-            delete_vectors=models.DeleteVectors(points=[1], vector=[""])
-        ),
-        models.OverwritePayloadOperation(
-            overwrite_payload=models.SetPayload(
-                payload={"test_payload": 1},
-                points=[1],
-            )
-        ),
-        models.SetPayloadOperation(
-            set_payload=models.SetPayload(
-                payload={
-                    "test_payload_2": 2,
-                    "test_payload_3": 3,
-                },
-                points=[1],
-            )
-        ),
-        models.DeletePayloadOperation(
-            delete_payload=models.DeletePayload(keys=["test_payload_2"], points=[1])
-        ),
-        models.ClearPayloadOperation(clear_payload=models.PointIdsList(points=[1])),
-        models.DeleteOperation(delete=models.PointIdsList(points=[1])),
-    ],
-)
-```
-
-```typescript
-client.batchUpdate("{collection_name}", {
-  operations: [
-    {
-      upsert: {
-        points: [
-          {
-            id: 1,
-            vector: [1.0, 2.0, 3.0, 4.0],
-            payload: {},
-          },
-        ],
-      },
-    },
-    {
-      update_vectors: {
-        points: [
-          {
-            id: 1,
-            vector: [1.0, 2.0, 3.0, 4.0],
-          },
-        ],
-      },
-    },
-    {
-      delete_vectors: {
-        points: [1],
-        vector: [""],
-      },
-    },
-    {
-      overwrite_payload: {
-        payload: {
-          test_payload: 1,
-        },
-        points: [1],
-      },
-    },
-    {
-      set_payload: {
-        payload: {
-          test_payload_2: 2,
-          test_payload_3: 3,
-        },
-        points: [1],
-      },
-    },
-    {
-      delete_payload: {
-        keys: ["test_payload_2"],
-        points: [1],
-      },
-    },
-    {
-      clear_payload: {
-        points: [1],
-      },
-    },
-    {
-      delete: {
-        points: [1],
-      },
-    },
-  ],
-});
-```
-
-```rust
-use std::collections::HashMap;
-
-use qdrant_client::qdrant::{
-    points_update_operation::{
-        ClearPayload, DeletePayload, DeletePoints, DeleteVectors, Operation, OverwritePayload,
-        PointStructList, SetPayload, UpdateVectors,
-    },
-    PointStruct, PointVectors, PointsUpdateOperation, UpdateBatchPointsBuilder, VectorsSelector,
-};
-use qdrant_client::Payload;
-
-client
-    .update_points_batch(
-        UpdateBatchPointsBuilder::new(
-            "{collection_name}",
-            vec![
-                PointsUpdateOperation {
-                    operation: Some(Operation::Upsert(PointStructList {
-                        points: vec![PointStruct::new(
-                            1,
-                            vec![1.0, 2.0, 3.0, 4.0],
-                            Payload::default(),
-                        )],
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::UpdateVectors(UpdateVectors {
-                        points: vec![PointVectors {
-                            id: Some(1.into()),
-                            vectors: Some(vec![1.0, 2.0, 3.0, 4.0].into()),
-                        }],
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::DeleteVectors(DeleteVectors {
-                        points_selector: Some(vec![1.into()].into()),
-                        vectors: Some(VectorsSelector {
-                            names: vec!["".into()],
-                        }),
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::OverwritePayload(OverwritePayload {
-                        points_selector: Some(vec![1.into()].into()),
-                        payload: HashMap::from([("test_payload".to_string(), 1.into())]),
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::SetPayload(SetPayload {
-                        points_selector: Some(vec![1.into()].into()),
-                        payload: HashMap::from([
-                            ("test_payload_2".to_string(), 2.into()),
-                            ("test_payload_3".to_string(), 3.into()),
-                        ]),
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::DeletePayload(DeletePayload {
-                        points_selector: Some(vec![1.into()].into()),
-                        keys: vec!["test_payload_2".to_string()],
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::ClearPayload(ClearPayload {
-                        points: Some(vec![1.into()].into()),
-                        ..Default::default()
-                    })),
-                },
-                PointsUpdateOperation {
-                    operation: Some(Operation::DeletePoints(DeletePoints {
-                        points: Some(vec![1.into()].into()),
-                        ..Default::default()
-                    })),
-                },
-            ],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.ValueFactory.value;
-import static io.qdrant.client.VectorsFactory.vectors;
-
-import io.qdrant.client.grpc.Points.PointStruct;
-import io.qdrant.client.grpc.Points.PointVectors;
-import io.qdrant.client.grpc.Points.PointsIdsList;
-import io.qdrant.client.grpc.Points.PointsSelector;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.ClearPayload;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeletePayload;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeletePoints;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeleteVectors;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.PointStructList;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.SetPayload;
-import io.qdrant.client.grpc.Points.PointsUpdateOperation.UpdateVectors;
-import io.qdrant.client.grpc.Points.VectorsSelector;
-
-client
-    .batchUpdateAsync(
-        "{collection_name}",
-        List.of(
-            PointsUpdateOperation.newBuilder()
-                .setUpsert(
-                    PointStructList.newBuilder()
-                        .addPoints(
-                            PointStruct.newBuilder()
-                                .setId(id(1))
-                                .setVectors(vectors(1.0f, 2.0f, 3.0f, 4.0f))
-                                .build())
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setUpdateVectors(
-                    UpdateVectors.newBuilder()
-                        .addPoints(
-                            PointVectors.newBuilder()
-                                .setId(id(1))
-                                .setVectors(vectors(1.0f, 2.0f, 3.0f, 4.0f))
-                                .build())
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setDeleteVectors(
-                    DeleteVectors.newBuilder()
-                        .setPointsSelector(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .setVectors(VectorsSelector.newBuilder().addNames("").build())
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setOverwritePayload(
-                    SetPayload.newBuilder()
-                        .setPointsSelector(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .putAllPayload(Map.of("test_payload", value(1)))
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setSetPayload(
-                    SetPayload.newBuilder()
-                        .setPointsSelector(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .putAllPayload(
-                            Map.of("test_payload_2", value(2), "test_payload_3", value(3)))
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setDeletePayload(
-                    DeletePayload.newBuilder()
-                        .setPointsSelector(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .addKeys("test_payload_2")
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setClearPayload(
-                    ClearPayload.newBuilder()
-                        .setPoints(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .build())
-                .build(),
-            PointsUpdateOperation.newBuilder()
-                .setDeletePoints(
-                    DeletePoints.newBuilder()
-                        .setPoints(
-                            PointsSelector.newBuilder()
-                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
-                                .build())
-                        .build())
-                .build()))
-    .get();
-```
+{{< code-snippet path="/documentation/headless/snippets/batch-update-points/basic/" >}}
 
 To batch many points with a single operation type, please use batching
 functionality in that operation directly.
diff --git a/qdrant-landing/content/documentation/concepts/search.md b/qdrant-landing/content/documentation/concepts/search.md
index 2c94f6623..f9512a6ef 100644
--- a/qdrant-landing/content/documentation/concepts/search.md
+++ b/qdrant-landing/content/documentation/concepts/search.md
@@ -37,175 +37,11 @@ Depending on the `query` parameter, Qdrant might prefer different strategies for
 
 **Nearest Neighbors Search**
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7] // <--- Dense vector
-}
-```
-
-```python
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7], # <--- Dense vector
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7], // <--- Dense vector
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Condition, Filter, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(Query::new_nearest(vec![0.2, 0.1, 0.9, 0.7]))
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-  .setCollectionName("{collectionName}")
-  .setQuery(nearest(List.of(0.2f, 0.1f, 0.9f, 0.7f)))
-  .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
- collectionName: "{collection_name}",
- query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/simple-dense/" >}}
 
 **Search By Id**
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": "43cf51e2-8777-4f52-bc74-c2cbde0c8b04" // <--- point id
-}
-```
-
-```python
-client.query_points(
-    collection_name="{collection_name}",
-    query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04", # <--- point id
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: '43cf51e2-8777-4f52-bc74-c2cbde0c8b04', // <--- point id
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Condition, Filter, PointId, Query, QueryPointsBuilder};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(Query::new_nearest(PointId::new("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
-    )
-    .await?;
-```
-
-```java
-import java.util.UUID;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-  .setCollectionName("{collectionName}")
-  .setQuery(nearest(UUID.fromString("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
-  .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: Guid.Parse("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQueryID(qdrant.NewID("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/by-existing-id/" >}}
 
 ## Metrics
 
@@ -240,160 +76,7 @@ Let's look at an example of a search query.
 
 REST API - API Schema definition is available [here](https://api.qdrant.tech/api-reference/search/query-points)
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.79],
-    "filter": {
-        "must": [
-            {
-                "key": "city",
-                "match": {
-                    "value": "London"
-                }
-            }
-        ]
-    },
-    "params": {
-        "hnsw_ef": 128,
-        "exact": false
-    },
-    "limit": 3
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    query_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="city",
-                match=models.MatchValue(
-                    value="London",
-                ),
-            )
-        ]
-    ),
-    search_params=models.SearchParams(hnsw_ef=128, exact=False),
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    filter: {
-        must: [
-            {
-                key: "city",
-                match: {
-                    value: "London",
-                },
-            },
-        ],
-    },
-    params: {
-        hnsw_ef: 128,
-        exact: false,
-    },
-    limit: 3,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, QueryPointsBuilder, SearchParamsBuilder};
-use qdrant_client::Qdrant;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .filter(Filter::must([Condition::matches(
-                "city",
-                "London".to_string(),
-            )]))
-            .params(SearchParamsBuilder::default().hnsw_ef(128).exact(false)),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-        .setFilter(Filter.newBuilder().addMust(matchKeyword("city", "London")).build())
-        .setParams(SearchParams.newBuilder().setExact(false).setHnswEf(128).build())
-        .setLimit(3)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-    filter: MatchKeyword("city", "London"),
-    searchParams: new SearchParams { Exact = false, HnswEf = 128 },
-    limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("city", "London"),
-		},
-	},
-	Params: &qdrant.SearchParams{
-		Exact:  qdrant.PtrOf(false),
-		HnswEf: qdrant.PtrOf(uint64(128)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/basic-with-filter-and-params/" >}}
 
 In this example, we are looking for vectors similar to vector `[0.2, 0.1, 0.9, 0.7]`.
 Parameter `limit` (or its alias - `top`) specifies the amount of most similar results we would like to retrieve.
@@ -428,116 +111,12 @@ Note that payload and vector data is missing in these results by default.
 See [payload and vector in the result](#payload-and-vector-in-the-result) on how
 to include it.
 
-*Available as of v0.10.0*
-
 If the collection was created with multiple vectors, the name of the vector to use for searching should be provided:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "using": "image",
-    "limit": 3
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    using="image",
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  using: "image",
-  limit: 3,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .using("image"),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-        .setUsing("image")
-        .setLimit(3)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	usingVector: "image",
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Using:          qdrant.PtrOf("image"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/named-vector/" >}}
 
 Search is processing only among vectors with the same name.
 
-*Available as of v1.7.0*
-
 If the collection was created with sparse vectors, the name of the sparse vector to use for searching should be provided:
 
 You can still use payload filtering and other features of the search API with sparse vectors.
@@ -552,120 +131,7 @@ There are however important differences between dense and sparse vector search:
 
 In general, the speed of the search is proportional to the number of non-zero values in the query vector.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-  "query": {
-    "indices": [6, 7],
-    "values": [1, 2]
-  },
-  "using": "text",
-  "limit": 3
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=models.SparseVector(
-        indices=[1, 7],
-        values=[2.0, 1.0],
-    ),
-    using="text",
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: {
-        indices: [1, 7],
-        values: [2.0, 1.0]
-    },
-    using: "text",
-    limit: 3,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![(1, 2.0), (7, 1.0)])
-            .limit(3)
-            .using("text"),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setUsing("text")
-                .setQuery(nearest(List.of(2.0f, 1.0f), List.of(1, 7)))
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new (float, uint)[] { (2.0f, 1), (1.0f, 2) },
-    usingVector: "text",
-    limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query: qdrant.NewQuerySparse(
-		[]uint32{1, 2},
-		[]float32{2.0, 1.0}),
-	Using: qdrant.PtrOf("text"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/sparse-vectors/" >}}
 
 ### Filtering results by score
 
@@ -684,340 +150,17 @@ alter this behavior.
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "with_vectors": true,
-    "with_payload": true
-}
-```
-
-```python
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    with_vectors=True,
-    with_payload=True,
-)
-```
-
-```typescript
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  with_vector: true,
-  with_payload: true,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .with_payload(true)
-            .with_vectors(true),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.WithVectorsSelectorFactory;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.WithPayloadSelectorFactory.enable;
-
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setWithPayload(enable(true))
-                .setWithVectors(WithVectorsSelectorFactory.enable(true))
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	payloadSelector: true,
-	vectorsSelector: true,
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	WithPayload:    qdrant.NewWithPayload(true),
-	WithVectors:    qdrant.NewWithVectors(true),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-payload-and-vectors/" >}}
 
 You can use `with_payload` to scope to or filter a specific payload subset.
 You can even specify an array of items to include, such as `city`,
 `village`, and `town`:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "with_payload": ["city", "village", "town"]
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    with_payload=["city", "village", "town"],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  with_payload: ["city", "village", "town"],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .with_payload(SelectorOptions::Include(
-                vec![
-                    "city".to_string(),
-                    "village".to_string(),
-                    "town".to_string(),
-                ]
-                .into(),
-            ))
-            .with_vectors(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.WithPayloadSelectorFactory.include;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setWithPayload(include(List.of("city", "village", "town")))
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-    payloadSelector: new WithPayloadSelector
-    {
-        Include = new PayloadIncludeSelector
-        {
-            Fields = { new string[] { "city", "village", "town" } }
-        }
-    },
-    limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	WithPayload:    qdrant.NewWithPayloadInclude("city", "village", "town"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-payload-fields/" >}}
 
 Or use `include` or `exclude` explicitly. For example, to exclude `city`:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "with_payload": {
-      "exclude": ["city"]
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    with_payload=models.PayloadSelectorExclude(
-        exclude=["city"],
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  with_payload: {
-    exclude: ["city"],
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .with_payload(SelectorOptions::Exclude(vec!["city".to_string()].into()))
-            .with_vectors(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.WithPayloadSelectorFactory.exclude;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setWithPayload(exclude(List.of("city")))
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	payloadSelector: new WithPayloadSelector
-	{
-		Exclude = new PayloadExcludeSelector { Fields = { new string[] { "city" } } }
-	},
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	WithPayload:    qdrant.NewWithPayloadExclude("city"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/exclude-fields/" >}}
 
 It is possible to target nested fields using a dot notation:
 * `payload.nested_field` - for a nested field
@@ -1027,8 +170,6 @@ Accessing array elements by index is currently not supported.
 
 ## Batch search API
 
-*Available as of v0.10.0*
-
 The batch search API enables to perform multiple search requests via a single request.
 
 Its semantic is straightforward, `n` batched search requests are equivalent to `n` singular search requests.
@@ -1041,221 +182,7 @@ This can have a great effect on latency for non trivial filters as the intermedi
 
 In order to use it, simply pack together your search requests. All the regular attributes of a search request are of course available.
 
-```http
-POST /collections/{collection_name}/points/query/batch
-{
-    "searches": [
-        {
-            "query": [0.2, 0.1, 0.9, 0.7],
-            "filter": {
-                "must": [
-                    {
-                        "key": "city",
-                        "match": {
-                            "value": "London"
-                        }
-                    }
-                ]
-            },
-            "limit": 3
-        },
-        {
-            "query": [0.5, 0.3, 0.2, 0.3],
-            "filter": {
-                "must": [
-                    {
-                        "key": "city",
-                        "match": {
-                            "value": "London"
-                        }
-                    }
-                ]
-            },
-            "limit": 3
-        }
-    ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-filter_ = models.Filter(
-    must=[
-        models.FieldCondition(
-            key="city",
-            match=models.MatchValue(
-                value="London",
-            ),
-        )
-    ]
-)
-
-search_queries = [
-    models.QueryRequest(query=[0.2, 0.1, 0.9, 0.7], filter=filter_, limit=3),
-    models.QueryRequest(query=[0.5, 0.3, 0.2, 0.3], filter=filter_, limit=3),
-]
-
-client.query_batch_points(collection_name="{collection_name}", requests=search_queries)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-const filter = {
-    must: [
-        {
-            key: "city",
-            match: {
-                value: "London",
-            },
-        },
-    ],
-};
-
-const searches = [
-    {
-        query: [0.2, 0.1, 0.9, 0.7],
-        filter,
-        limit: 3,
-    },
-    {
-        query: [0.5, 0.3, 0.2, 0.3],
-        filter,
-        limit: 3,
-    },
-];
-
-client.queryBatch("{collection_name}", {
-    searches,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, QueryBatchPointsBuilder, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let filter = Filter::must([Condition::matches("city", "London".to_string())]);
-
-let searches = vec![
-    QueryPointsBuilder::new("{collection_name}")
-        .query(vec![0.1, 0.2, 0.3, 0.4])
-        .limit(3)
-        .filter(filter.clone())
-        .build(),
-    QueryPointsBuilder::new("{collection_name}")
-        .query(vec![0.5, 0.3, 0.2, 0.3])
-        .limit(3)
-        .filter(filter)
-        .build(),
-];
-
-client
-        .query_batch(QueryBatchPointsBuilder::new("{collection_name}", searches))
-        .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-Filter filter = Filter.newBuilder().addMust(matchKeyword("city", "London")).build();
-
-List<QueryPoints> searches = List.of(
-        QueryPoints.newBuilder()
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setFilter(filter)
-                .setLimit(3)
-                .build(),
-        QueryPoints.newBuilder()
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setFilter(filter)
-                .setLimit(3)
-                .build());
-
-client.queryBatchAsync("{collection_name}", searches).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-var filter = MatchKeyword("city", "London");
-
-var queries = new List<QueryPoints>
-{
-    new()
-    {
-        CollectionName = "{collection_name}",
-        Query = new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-        Filter = filter,
-        Limit = 3
-    },
-    new()
-    {
-        CollectionName = "{collection_name}",
-        Query = new float[] { 0.5f, 0.3f, 0.2f, 0.3f },
-        Filter = filter,
-        Limit = 3
-    }
-};
-
-await client.QueryBatchAsync(collectionName: "{collection_name}", queries: queries);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-filter := qdrant.Filter{
-	Must: []*qdrant.Condition{
-		qdrant.NewMatch("city", "London"),
-	},
-}
-
-client.QueryBatch(context.Background(), &qdrant.QueryBatchPoints{
-	CollectionName: "{collection_name}",
-	QueryPoints: []*qdrant.QueryPoints{
-		{
-			CollectionName: "{collection_name}",
-			Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-			Filter:         &filter,
-		},
-		{
-			CollectionName: "{collection_name}",
-			Query:          qdrant.NewQuery(0.5, 0.3, 0.2, 0.3),
-			Filter:         &filter,
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/batch-search/" >}}
 
 The result of this API contains one array per search requests.
 
@@ -1278,133 +205,35 @@ The result of this API contains one array per search requests.
 }
 ```
 
-## Pagination
+## Query by ID
 
-*Available as of v0.8.3*
+Whenever you need to use a vector as an input, you can always use a [point ID](/documentation/concepts/points/#point-ids) instead.
+
+{{< code-snippet path="/documentation/headless/snippets/query-points/by-existing-id/" >}}
+
+The above example will fetch the default vector from the point with this id, and use it as the query vector.
+
+If the `using` parameter is also specified, Qdrant will use the vector with that name.
+
+It is also possible to reference an ID from a different collection, by setting the `lookup_from` parameter.
+
+{{< code-snippet path="/documentation/headless/snippets/query-points/by-existing-id-with-lookup/" >}}
+
+In the case above, Qdrant will fetch the `"image-512"` vector from the specified point id in the 
+collection `another_collection`.
+
+<aside role="status">
+ The fetched vector(s) must match the characteristics of the <code>using</code> vector, otherwise, an error will be returned.
+</aside>
+
+
+## Pagination
 
 Search and [recommendation](/documentation/concepts/explore/#recommendation-api) APIs allow to skip first results of the search and return only the result starting from some specified offset:
 
 Example:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "with_vectors": true,
-    "with_payload": true,
-    "limit": 10,
-    "offset": 100
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    with_vectors=True,
-    with_payload=True,
-    limit=10,
-    offset=100,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  with_vector: true,
-  with_payload: true,
-  limit: 10,
-  offset: 100,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .with_payload(true)
-            .with_vectors(true)
-            .limit(10)
-            .offset(100),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.WithVectorsSelectorFactory;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.WithPayloadSelectorFactory.enable;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setWithPayload(enable(true))
-                .setWithVectors(WithVectorsSelectorFactory.enable(true))
-                .setLimit(10)
-                .setOffset(100)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-    collectionName: "{collection_name}",
-    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-    payloadSelector: true,
-    vectorsSelector: true,
-    limit: 10,
-    offset: 100
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	WithPayload:    qdrant.NewWithPayload(true),
-	WithVectors:    qdrant.NewWithVectors(true),
-	Offset:         qdrant.PtrOf(uint64(100)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-offset/" >}}
 
 Is equivalent to retrieving the 11th page with 10 records per page.
 
@@ -1419,8 +248,6 @@ Using an `offset` parameter, will require to internally retrieve `offset + limit
 
 ## Grouping API
 
-*Available as of v1.2.0*
-
 It is possible to group results by a certain field. This is useful when you have multiple points for the same item, and you want to avoid redundancy of the same item in the results.
 
 For example, if you have a large document split into multiple chunks, and you want to search or [recommend](/documentation/concepts/explore/#recommendation-api) on a per-document basis, you can group the results by the document ID.
@@ -1486,103 +313,7 @@ With the ***groups*** API, you will be able to get the best *N* points for each
 
 REST API ([Schema](https://api.qdrant.tech/api-reference/search/query-points-groups)):
 
-```http
-POST /collections/{collection_name}/points/query/groups
-{
-    // Same as in the regular query API
-    "query": [1.1],
-    // Grouping parameters
-    "group_by": "document_id",  // Path of the field to group by
-    "limit": 4,                 // Max amount of groups
-    "group_size": 2            // Max amount of points per group
-}
-```
-
-```python
-client.query_points_groups(
-    collection_name="{collection_name}",
-    # Same as in the regular query_points() API
-    query=[1.1],
-    # Grouping parameters
-    group_by="document_id",  # Path of the field to group by
-    limit=4,  # Max amount of groups
-    group_size=2,  # Max amount of points per group
-)
-```
-
-```typescript
-client.queryGroups("{collection_name}", {
-    query: [1.1],
-    group_by: "document_id",
-    limit: 4,
-    group_size: 2,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointGroupsBuilder;
-
-client
-    .query_groups(
-        QueryPointGroupsBuilder::new("{collection_name}", "document_id")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .group_size(2u64)
-            .with_payload(true)
-            .with_vectors(true)
-            .limit(4u64),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.grpc.Points.SearchPointGroups;
-
-client.queryGroupsAsync(
-        QueryPointGroups.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setGroupBy("document_id")
-                .setLimit(4)
-                .setGroupSize(2)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryGroupsAsync(
-    collectionName: "{collection_name}",
-    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-    groupBy: "document_id",
-    limit: 4,
-    groupSize: 2
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	GroupBy:        "document_id",
-	GroupSize:      qdrant.PtrOf(uint64(2)),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-groups/basic/" >}}
 
 The output of a ***groups*** call looks like this:
 
@@ -1636,8 +367,6 @@ If the `group_by` field of a point is an array (e.g. `"document_id": ["a", "b"]`
 
 ### Lookup in groups
 
-*Available as of v1.3.0*
-
 Having multiple points for parts of the same item often introduces redundancy in the stored data. Which may be fine if the information shared by the points is small, but it can become a problem if the payload is large, because it multiplies the storage space needed to store the points by a factor of the amount of points we have per group.
 
 One way of optimizing storage when using groups is to store the information shared by the points with the same group id in a single point in another collection. Then, when using the [**groups** API](#grouping-api), add the `with_lookup` parameter to bring the information from those points into each group.
@@ -1652,164 +381,7 @@ For example, if you have a collection of documents, you may want to chunk them a
 
 In this case, to bring the information from the documents into the chunks grouped by the document id, you can use the `with_lookup` parameter:
 
-```http
-POST /collections/chunks/points/query/groups
-{
-    // Same as in the regular query API
-    "query": [1.1],
-
-    // Grouping parameters
-    "group_by": "document_id",
-    "limit": 2,
-    "group_size": 2,
-
-    // Lookup parameters
-    "with_lookup": {
-        // Name of the collection to look up points in
-        "collection": "documents",
-
-        // Options for specifying what to bring from the payload 
-        // of the looked up point, true by default
-        "with_payload": ["title", "text"],
-
-        // Options for specifying what to bring from the vector(s) 
-        // of the looked up point, true by default
-        "with_vectors": false
-    }
-}
-```
-
-```python
-client.query_points_groups(
-    collection_name="chunks",
-    # Same as in the regular search() API
-    query=[1.1],
-    # Grouping parameters
-    group_by="document_id",  # Path of the field to group by
-    limit=2,  # Max amount of groups
-    group_size=2,  # Max amount of points per group
-    # Lookup parameters
-    with_lookup=models.WithLookup(
-        # Name of the collection to look up points in
-        collection="documents",
-        # Options for specifying what to bring from the payload
-        # of the looked up point, True by default
-        with_payload=["title", "text"],
-        # Options for specifying what to bring from the vector(s)
-        # of the looked up point, True by default
-        with_vectors=False,
-    ),
-)
-```
-
-```typescript
-client.queryGroups("{collection_name}", {
-    query: [1.1],
-    group_by: "document_id",
-    limit: 2,
-    group_size: 2,
-    with_lookup: {
-        collection: "documents",
-        with_payload: ["title", "text"],
-        with_vectors: false,
-    },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointGroupsBuilder, WithLookupBuilder};
-
-client
-    .query_groups(
-        QueryPointGroupsBuilder::new("{collection_name}", "document_id")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(2u64)
-            .limit(2u64)
-            .with_lookup(
-                WithLookupBuilder::new("documents")
-                    .with_payload(SelectorOptions::Include(
-                        vec!["title".to_string(), "text".to_string()].into(),
-                    ))
-                    .with_vectors(false),
-            ),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.grpc.Points.QueryPointGroups;
-import io.qdrant.client.grpc.Points.WithLookup;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.WithVectorsSelectorFactory.enable;
-import static io.qdrant.client.WithPayloadSelectorFactory.include;
-
-client.queryGroupsAsync(
-        QueryPointGroups.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setGroupBy("document_id")
-                .setLimit(2)
-                .setGroupSize(2)
-                .setWithLookup(
-                        WithLookup.newBuilder()
-                                .setCollection("documents")
-                                .setWithPayload(include(List.of("title", "text")))
-                                .setWithVectors(enable(false))
-                                .build())
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.SearchGroupsAsync(
-    collectionName: "{collection_name}",
-    vector: new float[] { 0.2f, 0.1f, 0.9f, 0.7f},
-    groupBy: "document_id",
-    limit: 2,
-    groupSize: 2,
-    withLookup: new WithLookup
-    {
-        Collection = "documents",
-        WithPayload = new WithPayloadSelector
-        {
-            Include = new PayloadIncludeSelector { Fields = { new string[] { "title", "text" } } }
-        },
-        WithVectors = false
-    }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	GroupBy:        "document_id",
-	GroupSize:      qdrant.PtrOf(uint64(2)),
-	WithLookup: &qdrant.WithLookup{
-		Collection:  "documents",
-		WithPayload: qdrant.NewWithPayloadInclude("title", "text"),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-groups/with-lookup/" >}}
 
 For the `with_lookup` parameter, you can also use the shorthand `with_lookup="documents"` to bring the whole payload and vector(s) without explicitly specifying it.
 
@@ -1865,99 +437,7 @@ In some cases it might be useful to retrieve a random sample of points from the
 
 Random sampling API is a part of [Universal Query API](#query-api) and can be used in the same way as regular search API.
 
-```http
-{
-    "collection_name": "{collection_name}",
-    "query": {
-        "sample": "random"
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-
-sampled = client.query_points(
-    collection_name="{collection_name}",
-    query=models.SampleQuery(sample=models.Sample.RANDOM)
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-const sampled = await client.query("{collection_name}", {
-  query: {
-    sample: "random",
-  },
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{Query, QueryPointsBuilder};
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let sampled = client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(Query::new_sample(Sample::Random))
-    )
-    .await?;
-
-```
-
-```java
-import static io.qdrant.client.QueryFactory.sample;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.Sample;
-
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-
-client
-    .queryAsync(
-        QueryPoints.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setQuery(sample(Sample.Random))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(collectionName: "{collection_name}", query: Sample.Random);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuerySample(qdrant.Sample_Random),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/random-sample/" >}}
 
 ## Query planning
 
diff --git a/qdrant-landing/content/documentation/concepts/snapshots.md b/qdrant-landing/content/documentation/concepts/snapshots.md
index bb98da1a1..692eb32f2 100644
--- a/qdrant-landing/content/documentation/concepts/snapshots.md
+++ b/qdrant-landing/content/documentation/concepts/snapshots.md
@@ -21,66 +21,7 @@ For a step-by-step guide on how to use snapshots, see our [tutorial](/documentat
 
 To create a new snapshot for an existing collection:
 
-```http
-POST /collections/{collection_name}/snapshots
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_snapshot(collection_name="{collection_name}")
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createSnapshot("{collection_name}");
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_snapshot("{collection_name}").await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-      new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.createSnapshotAsync("{collection_name}").get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateSnapshotAsync("{collection_name}");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateSnapshot(context.Background(), "{collection_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/create-collection-snapshot/" >}}
 
 This is a synchronous operation for which a `tar` archive file will be generated into the `snapshot_path`.
 
@@ -88,139 +29,13 @@ This is a synchronous operation for which a `tar` archive file will be generated
 
 *Available as of v1.0.0*
 
-```http
-DELETE /collections/{collection_name}/snapshots/{snapshot_name}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.delete_snapshot(
-    collection_name="{collection_name}", snapshot_name="{snapshot_name}"
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.deleteSnapshot("{collection_name}", "{snapshot_name}");
-```
-
-```rust
-use qdrant_client::qdrant::DeleteSnapshotRequestBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .delete_snapshot(DeleteSnapshotRequestBuilder::new(
-        "{collection_name}",
-        "{snapshot_name}",
-    ))
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.deleteSnapshotAsync("{collection_name}", "{snapshot_name}").get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeleteSnapshotAsync(collectionName: "{collection_name}", snapshotName: "{snapshot_name}");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.DeleteSnapshot(context.Background(), "{collection_name}", "{snapshot_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/delete-collection-snapshot/" >}}
 
 ## List snapshot
 
 List of snapshots for a collection:
 
-```http
-GET /collections/{collection_name}/snapshots
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.list_snapshots(collection_name="{collection_name}")
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.listSnapshots("{collection_name}");
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.list_snapshots("{collection_name}").await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.listSnapshotAsync("{collection_name}").get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ListSnapshotsAsync("{collection_name}");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.ListSnapshots(context.Background(), "{collection_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/list-collection-snapshots/" >}}
 
 ## Retrieve snapshot
 
@@ -228,15 +43,7 @@ client.ListSnapshots(context.Background(), "{collection_name}")
 
 To download a specified snapshot from a collection as a file:
 
-```http
-GET /collections/{collection_name}/snapshots/{snapshot_name}
-```
-
-```shell
-curl 'http://{qdrant-url}:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.snapshot' \
-    -H 'api-key: ********' \
-    --output 'filename.snapshot'
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/download-collection-snapshot/" >}}
 
 ## Restore snapshot
 
@@ -259,33 +66,7 @@ This method of recovery requires the snapshot file to be downloadable from a URL
 
 To recover from a URL or local file use the [snapshot recovery endpoint](https://api.qdrant.tech/master/api-reference/snapshots/recover-from-snapshot). This endpoint accepts either a URL like `https://example.com` or a [file URI](https://en.wikipedia.org/wiki/File_URI_scheme) like `file:///tmp/snapshot-2022-10-10.snapshot`. If the target collection does not exist, it will be created.
 
-```http
-PUT /collections/{collection_name}/snapshots/recover
-{
-  "location": "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot"
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://qdrant-node-2:6333")
-
-client.recover_snapshot(
-    "{collection_name}",
-    "http://qdrant-node-1:6333/collections/collection_name/snapshots/snapshot-2022-10-10.shapshot",
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.recoverSnapshot("{collection_name}", {
-  location: "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
-});
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/" >}}
 
 <aside role="status">When recovering from a URL, the URL must be reachable by the Qdrant node that you are restoring. In Qdrant Cloud, restoring via URL is not supported since all outbound traffic is blocked for security purposes. You may still restore via file URI or via an uploaded file.</aside>
 
@@ -343,43 +124,7 @@ broken state.
 
 To recover from a URL, you specify an additional parameter in the request body:
 
-```http
-PUT /collections/{collection_name}/snapshots/recover
-{
-  "location": "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
-  "priority": "snapshot"
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://qdrant-node-2:6333")
-
-client.recover_snapshot(
-    "{collection_name}",
-    "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
-    priority=models.SnapshotPriority.SNAPSHOT,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.recoverSnapshot("{collection_name}", {
-  location: "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
-  priority: "snapshot"
-});
-```
-
-```bash
-curl -X POST 'http://qdrant-node-1:6333/collections/{collection_name}/snapshots/upload?priority=snapshot' \
-    -H 'api-key: ********' \
-    -H 'Content-Type:multipart/form-data' \
-    -F 'snapshot=@/path/to/snapshot-2022-10-10.shapshot'
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/" >}}
 
 ## Snapshots for the whole storage
 
@@ -394,202 +139,23 @@ Qdrant provides a dedicated API for that as well. It is similar to collection-le
 
 ### Create full storage snapshot
 
-```http
-POST /snapshots
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_full_snapshot()
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createFullSnapshot();
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_full_snapshot().await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.createFullSnapshotAsync().get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateFullSnapshotAsync();
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFullSnapshot(context.Background())
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/create-full-snapshot/" >}}
 
 ### Delete full storage snapshot
 
 *Available as of v1.0.0*
 
-```http
-DELETE /snapshots/{snapshot_name}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.delete_full_snapshot(snapshot_name="{snapshot_name}")
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.deleteFullSnapshot("{snapshot_name}");
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.delete_full_snapshot("{snapshot_name}").await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.deleteFullSnapshotAsync("{snapshot_name}").get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.DeleteFullSnapshotAsync("{snapshot_name}");
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.DeleteFullSnapshot(context.Background(), "{snapshot_name}")
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/delete-full-snapshot/" >}}
 
 ### List full storage snapshots
 
-```http
-GET /snapshots
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient("localhost", port=6333)
-
-client.list_full_snapshots()
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.listFullSnapshots();
-```
-
-```rust
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.list_full_snapshots().await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.listFullSnapshotAsync().get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.ListFullSnapshotsAsync();
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.ListFullSnapshots(context.Background())
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/list-full-snapshots/" >}}
 
 ### Download full storage snapshot
 
 <aside role="status">Only available through the REST API for the time being.</aside>
 
-```http
-GET /snapshots/{snapshot_name}
-```
+{{< code-snippet path="/documentation/headless/snippets/snapshots/download-full-snapshot/" >}}
 
 ## Restore full storage snapshot
 
diff --git a/qdrant-landing/content/documentation/concepts/storage.md b/qdrant-landing/content/documentation/concepts/storage.md
index 81048b447..1b2fe04e3 100644
--- a/qdrant-landing/content/documentation/concepts/storage.md
+++ b/qdrant-landing/content/documentation/concepts/storage.md
@@ -42,116 +42,7 @@ There are two ways to configure the usage of memmap(also known as on-disk) stora
 *Available as of v1.2.0*
 
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine",
-      "on_disk": true
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(
-        size=768, distance=models.Distance.COSINE, on_disk=True
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-    on_disk: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{CreateCollectionBuilder, Distance, VectorParamsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.VectorParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        "{collection_name}",
-        VectorParams.newBuilder()
-            .setSize(768)
-            .setDistance(Distance.Cosine)
-            .setOnDisk(true)
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	"{collection_name}",
-	new VectorParams
-	{
-		Size = 768,
-		Distance = Distance.Cosine,
-		OnDisk = true
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-		OnDisk:   qdrant.PtrOf(true),
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-vectors-on-disk/" >}}
 
 This will create a collection with all vectors immediately stored in memmap storage.
 This is the recommended way, in case your Qdrant instance operates with fast disks and you are working with large collections.
@@ -164,130 +55,7 @@ There are two ways to do this:
 1. You can set the threshold globally in the [configuration file](/documentation/guides/configuration/). The parameter is called `memmap_threshold` (previously `memmap_threshold_kb`).
 2. You can set the threshold for each collection separately during [creation](/documentation/concepts/collections/#create-collection) or [update](/documentation/concepts/collections/#update-collection-parameters).
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "optimizers_config": {
-        "memmap_threshold": 20000
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    optimizers_config=models.OptimizersConfigDiff(memmap_threshold=20000),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  optimizers_config: {
-    memmap_threshold: 20000,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .optimizers_config(OptimizersConfigDiffBuilder::default().memmap_threshold(20000)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setOptimizersConfig(
-                OptimizersConfigDiff.newBuilder().setMemmapThreshold(20000).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
-	optimizersConfig: new OptimizersConfigDiff { MemmapThreshold = 20000 }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{
-		MaxSegmentSize: qdrant.PtrOf(uint64(20000)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-optimizer-config/" >}}
 
 The rule of thumb to set the memmap threshold parameter is simple:
 
@@ -297,152 +65,14 @@ The rule of thumb to set the memmap threshold parameter is simple:
 In addition, you can use memmap storage not only for vectors, but also for HNSW index.
 To enable this, you need to set the `hnsw_config.on_disk` parameter to `true` during collection [creation](/documentation/concepts/collections/#create-a-collection) or [updating](/documentation/concepts/collections/#update-collection-parameters).
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "optimizers_config": {
-        "memmap_threshold": 20000
-    },
-    "hnsw_config": {
-        "on_disk": true
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    optimizers_config=models.OptimizersConfigDiff(memmap_threshold=20000),
-    hnsw_config=models.HnswConfigDiff(on_disk=True),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  optimizers_config: {
-    memmap_threshold: 20000,
-  },
-  hnsw_config: {
-    on_disk: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder, OptimizersConfigDiffBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .optimizers_config(OptimizersConfigDiffBuilder::default().memmap_threshold(20000))
-            .hnsw_config(HnswConfigDiffBuilder::default().on_disk(true)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.HnswConfigDiff;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setOptimizersConfig(
-                OptimizersConfigDiff.newBuilder().setMemmapThreshold(20000).build())
-            .setHnswConfig(HnswConfigDiff.newBuilder().setOnDisk(true).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
-	optimizersConfig: new OptimizersConfigDiff { MemmapThreshold = 20000 },
-	hnswConfig: new HnswConfigDiff { OnDisk = true }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{
-		MaxSegmentSize: qdrant.PtrOf(uint64(20000)),
-	},
-	HnswConfig: &qdrant.HnswConfigDiff{
-		OnDisk: qdrant.PtrOf(true),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/" >}}
 
 ## Payload storage
 
 Qdrant supports two types of payload storages: InMemory and OnDisk.
 
 InMemory payload storage is organized in the same way as in-memory vectors.
-The payload data is loaded into RAM at service startup while disk and [RocksDB](https://rocksdb.org/) are used for persistence only.
+The payload data is loaded into RAM at service startup while disk and [Gridstore](/articles/gridstore-key-value-storage/) are used for persistence only.
 This type of storage works quite fast, but it may require a lot of space to keep all the data in RAM, especially if the payload has large values attached - abstracts of text or even images.
 
 In the case of large payload values, it might be better to use OnDisk payload storage.
diff --git a/qdrant-landing/content/documentation/concepts/vectors.md b/qdrant-landing/content/documentation/concepts/vectors.md
index a16d2d530..6810c0863 100644
--- a/qdrant-landing/content/documentation/concepts/vectors.md
+++ b/qdrant-landing/content/documentation/concepts/vectors.md
@@ -83,396 +83,15 @@ Sparse vectors in Qdrant are kept in special storage and indexed in a separate i
 To create a collection with sparse vectors:
 
 
-```http
-PUT /collections/{collection_name}
-{
-    "sparse_vectors": {
-        "text": { },
-    }
-}
-```
-
-```bash
-curl -X PUT http://localhost:6333/collections/{collection_name} \
-  -H 'Content-Type: application/json' \
-  --data-raw '{
-    "sparse_vectors": {
-        "text": { }
-    }
-  }'
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={},
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(),
-    },
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  sparse_vectors: {
-    text: { },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
-};
-
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
-
-sparse_vectors_config.add_named_vector_params("text", SparseVectorParamsBuilder::default());
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .sparse_vectors_config(sparse_vectors_config),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setSparseVectorsConfig(
-                SparseVectorConfig.newBuilder()
-                    .putMap("text", SparseVectorParams.getDefaultInstance()))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	sparseVectorsConfig: ("text", new SparseVectorParams())
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text": {},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/sparse-vector/" >}}
 
 Insert a point with a sparse vector into the created collection:
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": {
-                "text": {
-                    "indices": [1, 3, 5, 7],
-                    "values": [0.1, 0.2, 0.3, 0.4]
-                }
-            }
-        }
-    ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            payload={},  # Add any additional payload if necessary
-            vector={
-                "text": models.SparseVector(
-                    indices=[1, 3, 5, 7],
-                    values=[0.1, 0.2, 0.3, 0.4]
-                )
-            },
-        )
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: {
-        text: {
-          indices: [1, 3, 5, 7],
-          values: [0.1, 0.2, 0.3, 0.4]
-        },
-      },
-    }
-  ]
-});
-```
-
-```rust
-use qdrant_client::qdrant::{NamedVectors, PointStruct, UpsertPointsBuilder, Vector};
-
-use qdrant_client::{Payload, Qdrant};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let points = vec![PointStruct::new(
-    1,
-    NamedVectors::default().add_vector(
-        "text",
-        Vector::new_sparse(vec![1, 3, 5, 7], vec![0.1, 0.2, 0.3, 0.4]),
-    ),
-    Payload::new(),
-)];
-
-client
-    .upsert_points(UpsertPointsBuilder::new("{collection_name}", points))
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorFactory.vector;
-import static io.qdrant.client.VectorsFactory.namedVectors;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-  .upsertAsync(
-    "{collection_name}",
-    List.of(
-      PointStruct.newBuilder()
-      .setId(id(1))
-      .setVectors(
-        namedVectors(Map.of(
-          "text", vector(List.of(1.0f, 2.0f), List.of(6, 7))))
-      )
-      .build()))
-  .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-  collectionName: "{collection_name}",
-  points: new List < PointStruct > {
-    new() {
-      Id = 1,
-        Vectors = new Dictionary <string, Vector> {
-          ["text"] = ([0.1f, 0.2f, 0.3f, 0.4f], [1, 3, 5, 7])
-        }
-    }
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMap(
-				map[string]*qdrant.Vector{
-					"text": qdrant.NewVectorSparse(
-						[]uint32{1, 3, 5, 7},
-						[]float32{0.1, 0.2, 0.3, 0.4}),
-				}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/sparse-vectors-single/" >}}
 
 Now you can run a search with sparse vectors:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": {
-        "indices": [1, 3, 5, 7],
-        "values": [0.1, 0.2, 0.3, 0.4]
-    },
-    "using": "text"
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-
-result = client.query_points(
-    collection_name="{collection_name}",
-    query=models.SparseVector(indices=[1, 3, 5, 7], values=[0.1, 0.2, 0.3, 0.4]),
-    using="text",
-).points
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![(1, 0.2), (3, 0.1), (5, 0.9), (7, 0.7)])
-            .limit(10)
-            .using("text"),
-    )
-    .await?;
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: {
-        indices: [1, 3, 5, 7],
-        values: [0.1, 0.2, 0.3, 0.4]
-    },
-    using: "text",
-    limit: 3,
-});
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setUsing("text")
-                .setQuery(nearest(List.of(0.1f, 0.2f, 0.3f, 0.4f), List.of(1, 3, 5, 7)))
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  query: new (float, uint)[] {(0.1f, 1), (0.2f, 3), (0.3f, 5), (0.4f, 7)},
-  usingVector: "text",
-  limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query: qdrant.NewQuerySparse(
-		[]uint32{1, 3, 5, 7},
-		[]float32{0.1, 0.2, 0.3, 0.4}),
-	Using: qdrant.PtrOf("text"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/sparse-vectors/" >}}
 
 ### Multivectors
 
@@ -514,414 +133,15 @@ Where $N$ is the number of vectors in the first matrix, $M$ is the number of vec
 
 To use multivectors, create a collection with the following configuration:
 
-```http
-PUT collections/{collection_name}
-{
-  "vectors": {
-    "size": 128,
-    "distance": "Cosine",
-    "multivector_config": {
-      "comparator": "max_sim"
-    }
-  }
-}
-```
-
-```python
-
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(
-        size=128,
-        distance=models.Distance.COSINE,
-        multivector_config=models.MultiVectorConfig(
-            comparator=models.MultiVectorComparator.MAX_SIM
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 128,
-    distance: "Cosine",
-    multivector_config: {
-      comparator: "max_sim"
-    }
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, VectorParamsBuilder,
-    MultiVectorComparator, MultiVectorConfigBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(
-                VectorParamsBuilder::new(100, Distance::Cosine)
-                    .multivector_config(
-                        MultiVectorConfigBuilder::new(MultiVectorComparator::MaxSim)
-                    ),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.MultiVectorComparator;
-import io.qdrant.client.grpc.Collections.MultiVectorConfig;
-import io.qdrant.client.grpc.Collections.VectorParams;
-
-QdrantClient client =
-  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.createCollectionAsync("{collection_name}",
-  VectorParams.newBuilder().setSize(128)
-  .setDistance(Distance.Cosine)
-  .setMultivectorConfig(MultiVectorConfig.newBuilder()
-    .setComparator(MultiVectorComparator.MaxSim)
-    .build())
-  .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  vectorsConfig: new VectorParams {
-    Size = 128,
-      Distance = Distance.Cosine,
-      MultivectorConfig = new() {
-        Comparator = MultiVectorComparator.MaxSim
-      }
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     128,
-		Distance: qdrant.Distance_Cosine,
-		MultivectorConfig: &qdrant.MultiVectorConfig{
-			Comparator: qdrant.MultiVectorComparator_MaxSim,
-		},
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-multivector/" >}}
 
 To insert a point with multivector:
 
-```http
-PUT collections/{collection_name}/points
-{
-  "points": [
-    {
-      "id": 1,
-      "vector": [
-        [-0.013,  0.020, -0.007, -0.111, ...],
-        [-0.030, -0.055,  0.001,  0.072, ...],
-        [-0.041,  0.014, -0.032, -0.062, ...]
-      ]
-    }
-  ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            vector=[
-                [-0.013,  0.020, -0.007, -0.111],
-                [-0.030, -0.055,  0.001,  0.072],
-                [-0.041,  0.014, -0.032, -0.062]
-            ],
-        )
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      vector: [
-        [-0.013,  0.020, -0.007, -0.111, ...],
-        [-0.030, -0.055,  0.001,  0.072, ...],
-        [-0.041,  0.014, -0.032, -0.062, ...]
-      ],
-    }
-  ]
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder, Vector};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let points = vec![
-    PointStruct::new(
-        1,
-        Vector::new_multi(vec![
-            vec![-0.013, 0.020, -0.007, -0.111],
-            vec![-0.030, -0.055, 0.001, 0.072],
-            vec![-0.041, 0.014, -0.032, -0.062],
-        ]),
-        Payload::new()
-    )
-];
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new("{collection_name}", points)
-    ).await?;
-
-```
-
-```java
-import java.util.List;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorsFactory.vectors;
-import static io.qdrant.client.VectorFactory.multiVector;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-.upsertAsync(
-    "{collection_name}",
-    List.of(
-        PointStruct.newBuilder()
-            .setId(id(1))
-            .setVectors(vectors(multiVector(new float[][] {
-                {-0.013f,  0.020f, -0.007f, -0.111f},
-                {-0.030f, -0.055f,  0.001f,  0.072f},
-                {-0.041f,  0.014f, -0.032f, -0.062f}
-            })))
-            .build()
-    ))
-.get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-  collectionName: "{collection_name}",
-  points: new List <PointStruct> {
-    new() {
-      Id = 1,
-        Vectors = new float[][] {
-          [-0.013f, 0.020f, -0.007f, -0.111f],
-          [-0.030f, -0.05f, 0.001f, 0.072f],
-          [-0.041f, 0.014f, -0.032f, -0.062f ],
-        },
-    },
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMulti(
-				[][]float32{
-					{-0.013, 0.020, -0.007, -0.111},
-					{-0.030, -0.055, 0.001, 0.072},
-					{-0.041, 0.014, -0.032, -0.062}}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/with-multivector/" >}}
 
 To search with multivector (available in `query` API): 
 
-```http
-POST collections/{collection_name}/points/query
-{
-  "query": [
-    [-0.013,  0.020, -0.007, -0.111, ...],
-    [-0.030, -0.055,  0.001,  0.072, ...],
-    [-0.041,  0.014, -0.032, -0.062, ...]
-  ]
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[
-        [-0.013,  0.020, -0.007, -0.111],
-        [-0.030, -0.055,  0.001,  0.072],
-        [-0.041,  0.014, -0.032, -0.062]
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  "query": [
-    [-0.013, 0.020, -0.007, -0.111],
-    [-0.030, -0.055, 0.001, 0.072],
-    [-0.041, 0.014, -0.032, -0.062]
-  ]
-});
-```
-
-```rust
-use qdrant_client::Qdrant;
-use qdrant_client::qdrant::{ QueryPointsBuilder, VectorInput };
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let res = client.query(
-    QueryPointsBuilder::new("{collection_name}")
-        .query(VectorInput::new_multi(
-            vec![
-                vec![-0.013,  0.020, -0.007, -0.111],
-                vec![-0.030, -0.055,  0.001,  0.072],
-                vec![-0.041,  0.014, -0.032, -0.062],
-            ]
-        ))
-).await?;
-```
-
-```java
-import static io.qdrant.client.QueryFactory.nearest;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-    .setCollectionName("{collection_name}")
-    .setQuery(nearest(new float[][] {
-        {-0.013f, 0.020f, -0.007f, -0.111f}, 
-        {-0.030f, -0.055f, 0.001f, 0.072f}, 
-        {-0.041f, 0.014f, -0.032f, -0.062f}
-    }))
-    .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-  collectionName: "{collection_name}",
-  query: new float[][] {
-    [-0.013f, 0.020f, -0.007f, -0.111f],
-    [-0.030f, -0.055f, 0.001 , 0.072f],
-    [-0.041f, 0.014f, -0.032f, -0.062f],
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query: qdrant.NewQueryMulti(
-		[][]float32{
-			{-0.013, 0.020, -0.007, -0.111},
-			{-0.030, -0.055, 0.001, 0.072},
-			{-0.041, 0.014, -0.032, -0.062},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/multivector/" >}}
 
 
 ## Named Vectors
@@ -936,449 +156,15 @@ Each vector should have a unique name. Vectors can represent different modalitie
 
 To create a collection with named vectors, you need to specify a configuration for each vector:
 
-```http
-PUT /collections/{collection_name}
-{
-  "vectors": {
-    "image": {
-      "size": 4,
-      "distance": "Dot"
-    },
-    "text": {
-      "size": 5,
-      "distance": "Cosine"
-    }
-  },
-  "sparse_vectors": {
-    "text-sparse": {}
-  }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config={
-        "image": models.VectorParams(size=4, distance=models.Distance.DOT),
-        "text": models.VectorParams(size=5, distance=models.Distance.COSINE),
-    },
-    sparse_vectors_config={"text-sparse": models.SparseVectorParams()},
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-    vectors: {
-        image: { size: 4, distance: "Dot" },
-        text: { size: 5, distance: "Cosine" },
-    },
-    sparse_vectors: {
-        text_sparse: {}
-    }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
-    VectorParamsBuilder, VectorsConfigBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut vector_config = VectorsConfigBuilder::default();
-vector_config.add_named_vector_params("text", VectorParamsBuilder::new(5, Distance::Dot));
-vector_config.add_named_vector_params("image", VectorParamsBuilder::new(4, Distance::Cosine));
-
-let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
-sparse_vectors_config
-    .add_named_vector_params("text-sparse", SparseVectorParamsBuilder::default());
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(vector_config)
-            .sparse_vectors_config(sparse_vectors_config),
-    )
-    .await?;
-```
-
-```java
-import java.util.Map;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorParamsMap;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(VectorsConfig.newBuilder().setParamsMap(
-                VectorParamsMap.newBuilder().putAllMap(Map.of("image",
-                    VectorParams.newBuilder()
-                        .setSize(4)
-                        .setDistance(Distance.Dot)
-                        .build(),
-                    "text",
-                    VectorParams.newBuilder()
-                        .setSize(5)
-                        .setDistance(Distance.Cosine)
-                        .build()))))
-            .setSparseVectorsConfig(SparseVectorConfig.newBuilder().putMap(
-                "text-sparse", SparseVectorParams.getDefaultInstance()))
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  vectorsConfig: new VectorParamsMap
-  {
-      Map = {
-      ["image"] = new VectorParams {
-        Size = 4, Distance = Distance.Dot
-      },
-      ["text"] = new VectorParams {
-        Size = 5, Distance = Distance.Cosine
-      },
-    }
-  },
-  sparseVectorsConfig: new SparseVectorConfig
-  {
-      Map = {
-        ["text-sparse"] = new()
-    }
-  }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfigMap(
-		map[string]*qdrant.VectorParams{
-			"image": {
-				Size:     4,
-				Distance: qdrant.Distance_Dot,
-			},
-			"text": {
-				Size:     5,
-				Distance: qdrant.Distance_Cosine,
-			},
-		}),
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text-sparse": {},
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/named-vectors/" >}}
 
 To insert a point with named vectors:
 
-```http
-PUT /collections/{collection_name}/points?wait=true
-{
-    "points": [
-        {
-            "id": 1,
-            "vector": {
-                "image": [0.9, 0.1, 0.1, 0.2],
-                "text": [0.4, 0.7, 0.1, 0.8, 0.1],
-                "text-sparse": {
-                  "indices": [1, 3, 5, 7],
-                  "values": [0.1, 0.2, 0.3, 0.4]
-                }
-            }
-        }
-    ]
-}
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/named-vectors/" >}}
 
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            vector={
-                "image": [0.9, 0.1, 0.1, 0.2],
-                "text": [0.4, 0.7, 0.1, 0.8, 0.1],
-                "text-sparse": {
-                    "indices": [1, 3, 5, 7],
-                    "values": [0.1, 0.2, 0.3, 0.4],
-                },
-            },
-        ),
-    ],
-)
-```
-
-```typescript
-client.upsert("{collection_name}", {
-    points: [
-        {
-            id: 1,
-            vector: {
-                image: [0.9, 0.1, 0.1, 0.2],
-                text: [0.4, 0.7, 0.1, 0.8, 0.1],
-                text_sparse: {
-                    indices: [1, 3, 5, 7],
-                    values: [0.1, 0.2, 0.3, 0.4]
-                }
-            },
-        },
-    ],
-});
-```
-
-```rust
-
-use qdrant_client::qdrant::{
-    NamedVectors, PointStruct, UpsertPointsBuilder, Vector,
-};
-use qdrant_client::Payload;
-
-client
-    .upsert_points(
-        UpsertPointsBuilder::new(
-            "{collection_name}",
-            vec![PointStruct::new(
-                1,
-                NamedVectors::default()
-                    .add_vector("text", Vector::new_dense(vec![0.4, 0.7, 0.1, 0.8, 0.1]))
-                    .add_vector("image", Vector::new_dense(vec![0.9, 0.1, 0.1, 0.2]))
-                    .add_vector(
-                        "text-sparse",
-                        Vector::new_sparse(vec![1, 3, 5, 7], vec![0.1, 0.2, 0.3, 0.4]),
-                    ),
-                Payload::default(),
-            )],
-        )
-        .wait(true),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import static io.qdrant.client.PointIdFactory.id;
-import static io.qdrant.client.VectorFactory.vector;
-import static io.qdrant.client.VectorsFactory.namedVectors;
-
-import io.qdrant.client.grpc.Points.PointStruct;
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(
-                    namedVectors(
-                        Map.of(
-                            "image",
-                            vector(List.of(0.9f, 0.1f, 0.1f, 0.2f)),
-                            "text",
-                            vector(List.of(0.4f, 0.7f, 0.1f, 0.8f, 0.1f)),
-                            "text-sparse",
-                            vector(List.of(0.1f, 0.2f, 0.3f, 0.4f), List.of(1, 3, 5, 7)))))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-await client.UpsertAsync(
-    collectionName: "{collection_name}",
-    points: new List<PointStruct>
-    {
-        new()
-        {
-            Id = 1,
-            Vectors = new Dictionary<string, Vector>
-            {
-                ["image"] = new() {
-                    Data = {0.9f, 0.1f, 0.1f, 0.2f}
-                },
-                ["text"] = new() {
-                    Data = {0.4f, 0.7f, 0.1f, 0.8f, 0.1f}
-                },
-                ["text-sparse"] = ([0.1f, 0.2f, 0.3f, 0.4f], [1, 3, 5, 7]),
-            }
-        }
-    }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id: qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
-				"image": qdrant.NewVector(0.9, 0.1, 0.1, 0.2),
-				"text":  qdrant.NewVector(0.4, 0.7, 0.1, 0.8, 0.1),
-				"text-sparse": qdrant.NewVectorSparse(
-					[]uint32{1, 3, 5, 7},
-					[]float32{0.1, 0.2, 0.3, 0.4}),
-			}),
-		},
-	},
-})
-```
-
-You can also upload
 To search with named vectors (available in `query` API):
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "using": "image",
-    "limit": 3
-}
-```
-
-```python
-from qdrant_client import QdrantClient
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    using="image",
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-  query: [0.2, 0.1, 0.9, 0.7],
-  using: "image",
-  limit: 3,
-});
-```
-
-```rust
-use qdrant_client::qdrant::QueryPointsBuilder;
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .using("image"),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(QueryPoints.newBuilder()
-        .setCollectionName("{collection_name}")
-        .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-        .setUsing("image")
-        .setLimit(3)
-        .build()).get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	usingVector: "image",
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Using:          qdrant.PtrOf("image"),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/named-vector/" >}}
 
 ## Datatypes
 
@@ -1418,178 +204,7 @@ The main advantage of Float16 is that it requires half the memory of Float32, wh
 
 To use Float16, you need to specify the datatype for vectors in the collection configuration:
 
-```http
-PUT /collections/{collection_name}
-{
-  "vectors": {
-    "size": 128,
-    "distance": "Cosine",
-    "datatype": "float16" // <-- For dense vectors
-  },
-  "sparse_vectors": {
-    "text": {
-      "index": {
-        "datatype": "float16" // <-- And for sparse vectors 
-      }
-    }
-  }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(
-        size=128,
-        distance=models.Distance.COSINE,
-        datatype=models.Datatype.FLOAT16
-    ),
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(
-            index=models.SparseIndexParams(datatype=models.Datatype.FLOAT16)
-        ),
-    },
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 128,
-    distance: "Cosine",
-    datatype: "float16"
-  },
-  sparse_vectors: {
-    text: {
-      index: {
-        datatype: "float16"
-      }
-    }
-  }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Datatype, Distance, SparseIndexConfigBuilder, SparseVectorParamsBuilder, SparseVectorsConfigBuilder, VectorParamsBuilder
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
-sparse_vector_config.add_named_vector_params(
-    "text",
-    SparseVectorParamsBuilder::default()
-        .index(SparseIndexConfigBuilder::default().datatype(Datatype::Float32)),
-);
-
-let create_collection = CreateCollectionBuilder::new("{collection_name}")
-    .sparse_vectors_config(sparse_vector_config)
-    .vectors_config(
-        VectorParamsBuilder::new(128, Distance::Cosine).datatype(Datatype::Float16),
-    );
-
-client.create_collection(create_collection).await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Datatype;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.SparseIndexConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-  .createCollectionAsync(
-    CreateCollection.newBuilder()
-    .setCollectionName("{collection_name}")
-    .setVectorsConfig(VectorsConfig.newBuilder()
-      .setParams(VectorParams.newBuilder()
-        .setSize(128)
-        .setDistance(Distance.Cosine)
-        .setDatatype(Datatype.Float16)
-        .build())
-      .build())
-    .setSparseVectorsConfig(
-      SparseVectorConfig.newBuilder()
-      .putMap("text", SparseVectorParams.newBuilder()
-        .setIndex(SparseIndexConfig.newBuilder()
-          .setDatatype(Datatype.Float16)
-          .build())
-        .build()))
-    .build())
-  .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  vectorsConfig: new VectorParams {
-    Size = 128,
-      Distance = Distance.Cosine,
-      Datatype = Datatype.Float16
-  },
-  sparseVectorsConfig: (
-    "text",
-    new SparseVectorParams {
-      Index = new SparseIndexConfig {
-        Datatype = Datatype.Float16
-      }
-    }
-  )
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     128,
-		Distance: qdrant.Distance_Cosine,
-		Datatype: qdrant.Datatype_Float16.Enum(),
-	}),
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text": {
-				Index: &qdrant.SparseIndexConfig{
-					Datatype: qdrant.Datatype_Float16.Enum(),
-				},
-			},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/" >}}
 
 **Uint8**
 
@@ -1612,181 +227,7 @@ Dense vectors are required to be in the range from 0 to 255, while sparse vector
 </aside>
 
 
-```http
-PUT /collections/{collection_name}
-{
-  "vectors": {
-    "size": 128,
-    "distance": "Cosine",
-    "datatype": "uint8" // <-- For dense vectors
-  },
-  "sparse_vectors": {
-    "text": {
-      "index": {
-        "datatype": "uint8" // <-- For sparse vectors 
-      }
-    }
-  }
-}
-```
-
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(
-        size=128, distance=models.Distance.COSINE, datatype=models.Datatype.UINT8
-    ),
-    sparse_vectors_config={
-        "text": models.SparseVectorParams(
-            index=models.SparseIndexParams(datatype=models.Datatype.UINT8)
-        ),
-    },
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 128,
-    distance: "Cosine",
-    datatype: "uint8"
-  },
-  sparse_vectors: {
-    text: {
-      index: {
-        datatype: "uint8"
-      }
-    }
-  }
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Datatype, Distance, SparseIndexConfigBuilder,
-    SparseVectorParamsBuilder, SparseVectorsConfigBuilder, VectorParamsBuilder,
-};
-
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
-
-sparse_vector_config.add_named_vector_params(
-    "text",
-    SparseVectorParamsBuilder::default()
-        .index(SparseIndexConfigBuilder::default().datatype(Datatype::Uint8)),
-);
-let create_collection = CreateCollectionBuilder::new("{collection_name}")
-    .sparse_vectors_config(sparse_vector_config)
-    .vectors_config(
-        VectorParamsBuilder::new(128, Distance::Cosine)
-            .datatype(Datatype::Uint8)
-    );
-
-client.create_collection(create_collection).await?;
-```
-
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Datatype;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.SparseIndexConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorConfig;
-import io.qdrant.client.grpc.Collections.SparseVectorParams;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-  .createCollectionAsync(
-    CreateCollection.newBuilder()
-    .setCollectionName("{collection_name}")
-    .setVectorsConfig(VectorsConfig.newBuilder()
-      .setParams(VectorParams.newBuilder()
-        .setSize(128)
-        .setDistance(Distance.Cosine)
-        .setDatatype(Datatype.Uint8)
-        .build())
-      .build())
-    .setSparseVectorsConfig(
-      SparseVectorConfig.newBuilder()
-      .putMap("text", SparseVectorParams.newBuilder()
-        .setIndex(SparseIndexConfig.newBuilder()
-          .setDatatype(Datatype.Uint8)
-          .build())
-        .build()))
-    .build())
-  .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-  collectionName: "{collection_name}",
-  vectorsConfig: new VectorParams {
-    Size = 128,
-      Distance = Distance.Cosine,
-      Datatype = Datatype.Uint8
-  },
-  sparseVectorsConfig: (
-    "text",
-    new SparseVectorParams {
-      Index = new SparseIndexConfig {
-        Datatype = Datatype.Uint8
-      }
-    }
-  )
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     128,
-		Distance: qdrant.Distance_Cosine,
-		Datatype: qdrant.Datatype_Uint8.Enum(),
-	}),
-	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
-		map[string]*qdrant.SparseVectorParams{
-			"text": {
-				Index: &qdrant.SparseIndexConfig{
-					Datatype: qdrant.Datatype_Uint8.Enum(),
-				},
-			},
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/" >}}
 
 ## Quantization
 
diff --git a/qdrant-landing/content/documentation/guides/multiple-partitions.md b/qdrant-landing/content/documentation/guides/multiple-partitions.md
index 16d6bd00f..c1e74c1a4 100644
--- a/qdrant-landing/content/documentation/guides/multiple-partitions.md
+++ b/qdrant-landing/content/documentation/guides/multiple-partitions.md
@@ -15,338 +15,16 @@ aliases:
 
 When an instance is shared between multiple users, you may need to partition vectors by user. This is done so that each user can only access their own vectors and can't see the vectors of other users.
 
-> ### NOTE
->
-> The key doesn't necessarily need to be named `group_id`. You can choose a name that best suits your data structure and naming conventions.
 
-1. Add a `group_id` field to each vector in the collection.
+<aside role="alert">
+    Note: The key doesn't necessarily need to be named <code>group_id</code>. You can choose a name that best suits your data structure and naming conventions.
+</aside>
 
-```http
-PUT /collections/{collection_name}/points
-{
-    "points": [
-        {
-            "id": 1,
-            "payload": {"group_id": "user_1"},
-            "vector": [0.9, 0.1, 0.1]
-        },
-        {
-            "id": 2,
-            "payload": {"group_id": "user_1"},
-            "vector": [0.1, 0.9, 0.1]
-        },
-        {
-            "id": 3,
-            "payload": {"group_id": "user_2"},
-            "vector": [0.1, 0.1, 0.9]
-        },
-    ]
-}
-```
-
-```python
-client.upsert(
-    collection_name="{collection_name}",
-    points=[
-        models.PointStruct(
-            id=1,
-            payload={"group_id": "user_1"},
-            vector=[0.9, 0.1, 0.1],
-        ),
-        models.PointStruct(
-            id=2,
-            payload={"group_id": "user_1"},
-            vector=[0.1, 0.9, 0.1],
-        ),
-        models.PointStruct(
-            id=3,
-            payload={"group_id": "user_2"},
-            vector=[0.1, 0.1, 0.9],
-        ),
-    ],
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.upsert("{collection_name}", {
-  points: [
-    {
-      id: 1,
-      payload: { group_id: "user_1" },
-      vector: [0.9, 0.1, 0.1],
-    },
-    {
-      id: 2,
-      payload: { group_id: "user_1" },
-      vector: [0.1, 0.9, 0.1],
-    },
-    {
-      id: 3,
-      payload: { group_id: "user_2" },
-      vector: [0.1, 0.1, 0.9],
-    },
-  ],
-});
-```
-
-```rust
-use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .upsert_points(UpsertPointsBuilder::new(
-        "{collection_name}",
-        vec![
-            PointStruct::new(1, vec![0.9, 0.1, 0.1], [("group_id", "user_1".into())]),
-            PointStruct::new(2, vec![0.1, 0.9, 0.1], [("group_id", "user_1".into())]),
-            PointStruct::new(3, vec![0.1, 0.1, 0.9], [("group_id", "user_2".into())]),
-        ],
-    ))
-    .await?;
-```
-
-```java
-import java.util.List;
-import java.util.Map;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.PointStruct;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .upsertAsync(
-        "{collection_name}",
-        List.of(
-            PointStruct.newBuilder()
-                .setId(id(1))
-                .setVectors(vectors(0.9f, 0.1f, 0.1f))
-                .putAllPayload(Map.of("group_id", value("user_1")))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(2))
-                .setVectors(vectors(0.1f, 0.9f, 0.1f))
-                .putAllPayload(Map.of("group_id", value("user_1")))
-                .build(),
-            PointStruct.newBuilder()
-                .setId(id(3))
-                .setVectors(vectors(0.1f, 0.1f, 0.9f))
-                .putAllPayload(Map.of("group_id", value("user_2")))
-                .build()))
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.UpsertAsync(
-	collectionName: "{collection_name}",
-	points: new List<PointStruct>
-	{
-		new()
-		{
-			Id = 1,
-			Vectors = new[] { 0.9f, 0.1f, 0.1f },
-			Payload = { ["group_id"] = "user_1" }
-		},
-		new()
-		{
-			Id = 2,
-			Vectors = new[] { 0.1f, 0.9f, 0.1f },
-			Payload = { ["group_id"] = "user_1" }
-		},
-		new()
-		{
-			Id = 3,
-			Vectors = new[] { 0.1f, 0.1f, 0.9f },
-			Payload = { ["group_id"] = "user_2" }
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Upsert(context.Background(), &qdrant.UpsertPoints{
-	CollectionName: "{collection_name}",
-	Points: []*qdrant.PointStruct{
-		{
-			Id:      qdrant.NewIDNum(1),
-			Vectors: qdrant.NewVectors(0.9, 0.1, 0.1),
-			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_1"}),
-		},
-		{
-			Id:      qdrant.NewIDNum(2),
-			Vectors: qdrant.NewVectors(0.1, 0.9, 0.1),
-			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_1"}),
-		},
-		{
-			Id:      qdrant.NewIDNum(3),
-			Vectors: qdrant.NewVectors(0.1, 0.1, 0.9),
-			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_2"}),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/insert-points/with-tenant-group-id/" >}}
 
 2. Use a filter along with `group_id` to filter vectors for each user.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.1, 0.1, 0.9],
-    "filter": {
-        "must": [
-            {
-                "key": "group_id",
-                "match": {
-                    "value": "user_1"
-                }
-            }
-        ]
-    },
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.1, 0.1, 0.9],
-    query_filter=models.Filter(
-        must=[
-            models.FieldCondition(
-                key="group_id",
-                match=models.MatchValue(
-                    value="user_1",
-                ),
-            )
-        ]
-    ),
-    limit=10,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.1, 0.1, 0.9],
-    filter: {
-        must: [{ key: "group_id", match: { value: "user_1" } }],
-    },
-    limit: 10,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{Condition, Filter, QueryPointsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.1, 0.1, 0.9])
-            .limit(10)
-            .filter(Filter::must([Condition::matches(
-                "group_id",
-                "user_1".to_string(),
-            )])),
-    )
-    .await?;
-```
-
-```java
-import java.util.List;
-
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.Filter;
-import io.qdrant.client.grpc.Points.QueryPoints;
-
-import static io.qdrant.client.QueryFactory.nearest;
-import static io.qdrant.client.ConditionFactory.matchKeyword;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setFilter(
-                        Filter.newBuilder().addMust(matchKeyword("group_id", "user_1")).build())
-                .setQuery(nearest(0.1f, 0.1f, 0.9f))
-                .setLimit(10)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using static Qdrant.Client.Grpc.Conditions;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.1f, 0.1f, 0.9f },
-	filter: MatchKeyword("group_id", "user_1"),
-	limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.1, 0.1, 0.9),
-	Filter: &qdrant.Filter{
-		Must: []*qdrant.Condition{
-			qdrant.NewMatch("group_id", "user_1"),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-filter-by-group-id/" >}}
 
 ## Calibrate performance
 
@@ -359,135 +37,7 @@ To implement this approach, you should:
 1. Set `payload_m` in the HNSW configuration to a non-zero value, such as 16.
 2. Set `m` in hnsw config to 0. This will disable building global index for the whole collection.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "hnsw_config": {
-        "payload_m": 16,
-        "m": 0
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    hnsw_config=models.HnswConfigDiff(
-        payload_m=16,
-        m=0,
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  hnsw_config: {
-    payload_m: 16,
-    m: 0,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder, VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .hnsw_config(HnswConfigDiffBuilder::default().payload_m(16).m(0)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.HnswConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setHnswConfig(HnswConfigDiff.newBuilder().setPayloadM(16).setM(0).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
-	hnswConfig: new HnswConfigDiff { PayloadM = 16, M = 0 }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	HnswConfig: &qdrant.HnswConfigDiff{
-		PayloadM: qdrant.PtrOf(uint64(16)),
-		M:        qdrant.PtrOf(uint64(0)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/" >}}
 
 3. Create keyword payload index for `group_id` field.
 
@@ -496,128 +46,7 @@ client.CreateCollection(context.Background(), &qdrant.CreateCollection{
 </aside>
 
 
-```http
-PUT /collections/{collection_name}/index
-{
-    "field_name": "group_id",
-    "field_schema": {
-        "type": "keyword",
-        "is_tenant": true
-    }
-}
-```
-
-```python
-client.create_payload_index(
-    collection_name="{collection_name}",
-    field_name="group_id",
-    field_schema=models.KeywordIndexParams(
-        type="keyword",
-        is_tenant=True,
-    ),
-)
-```
-
-```typescript
-client.createPayloadIndex("{collection_name}", {
-  field_name: "group_id",
-  field_schema: {
-    type: "keyword",
-    is_tenant: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateFieldIndexCollectionBuilder,
-    KeywordIndexParamsBuilder,
-    FieldType
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client.create_field_index(
-        CreateFieldIndexCollectionBuilder::new(
-            "{collection_name}",
-            "group_id",
-            FieldType::Keyword,
-        ).field_index_params(
-            KeywordIndexParamsBuilder::default()
-                .is_tenant(true)
-        )
-    ).await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.PayloadIndexParams;
-import io.qdrant.client.grpc.Collections.PayloadSchemaType;
-import io.qdrant.client.grpc.Collections.KeywordIndexParams;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createPayloadIndexAsync(
-        "{collection_name}",
-        "group_id",
-        PayloadSchemaType.Keyword,
-        PayloadIndexParams.newBuilder()
-            .setKeywordIndexParams(
-                KeywordIndexParams.newBuilder()
-                    .setIsTenant(true)
-                    .build())
-            .build(),
-        null,
-        null,
-        null)
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreatePayloadIndexAsync(
-	collectionName: "{collection_name}",
-	fieldName: "group_id",
-	schemaType: PayloadSchemaType.Keyword,
-	indexParams: new PayloadIndexParams
-	{
-		KeywordIndexParams = new KeywordIndexParams
-		{
-			IsTenant = true
-		}
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
-	CollectionName: "{collection_name}",
-	FieldName:      "group_id",
-	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
-	FieldIndexParams: qdrant.NewPayloadIndexParams(
-		&qdrant.KeywordIndexParams{
-			IsTenant: qdrant.PtrOf(true),
-		}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/" >}}
 
 `is_tenant=true` parameter is optional, but specifying it provides storage with additional information about the usage patterns the collection is going to use.
 When specified, storage structure will be organized in a way to co-locate vectors of the same tenant together, which can significantly improve performance in some cases. 
diff --git a/qdrant-landing/content/documentation/guides/optimize.md b/qdrant-landing/content/documentation/guides/optimize.md
index e65224986..43ae31d54 100644
--- a/qdrant-landing/content/documentation/guides/optimize.md
+++ b/qdrant-landing/content/documentation/guides/optimize.md
@@ -27,296 +27,13 @@ To configure in-memory quantization, with on-disk original vectors, you need to
 - `quantization_config`: Compresses quantized vectors to `int8` using the `scalar` method.
 - `always_ram`: Keeps quantized vectors in RAM.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-        "size": 768,
-        "distance": "Cosine",
-        "on_disk": true
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-    on_disk: true,
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .quantization_config(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .always_ram(true),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .setOnDisk(true)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setAlwaysRam(true)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true },
-	quantizationConfig: new QuantizationConfig
-	{
-		Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = true }
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-		OnDisk:   qdrant.PtrOf(true),
-	}),
-	QuantizationConfig: qdrant.NewQuantizationScalar(&qdrant.ScalarQuantization{
-		Type:      qdrant.QuantizationType_Int8,
-		AlwaysRam: qdrant.PtrOf(true),
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/" >}}
 
 ### Disable Rescoring for Faster Search (optional)
 
 This is completely optional. Disabling rescoring with search `params` can further reduce the number of disk reads. Note that this might slightly decrease precision.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "params": {
-        "quantization": {
-            "rescore": false
-        }
-    },
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    search_params=models.SearchParams(
-        quantization=models.QuantizationSearchParams(rescore=False)
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    params: {
-        quantization: {
-            rescore: false,
-        },
-    },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .params(
-                SearchParamsBuilder::default()
-                    .quantization(QuantizationSearchParamsBuilder::default().rescore(false)),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QuantizationSearchParams;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setParams(
-                        SearchParams.newBuilder()
-                                .setQuantization(
-                                        QuantizationSearchParams.newBuilder().setRescore(false).build())
-                                .build())
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	searchParams: new SearchParams
-	{
-		Quantization = new QuantizationSearchParams { Rescore = false }
-	},
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Params: &qdrant.SearchParams{
-		Quantization: &qdrant.QuantizationSearchParams{
-			Rescore: qdrant.PtrOf(true),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/disable-quantization-rescoring/" >}}
 
 ## 2. High Precision with Low Memory Usage
 
@@ -324,134 +41,7 @@ If you require high precision but have limited RAM, you can store both vectors a
 
 To store the vectors `on_disk`, you need to configure both the vectors and the HNSW index:
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine",
-      "on_disk": true
-    },
-    "hnsw_config": {
-        "on_disk": true
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
-    hnsw_config=models.HnswConfigDiff(on_disk=True),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-    on_disk: true,
-  },
-  hnsw_config: {
-    on_disk: true,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder, VectorParamsBuilder,
-};
-use qdrant_client::{Qdrant, QdrantError};
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
-            .hnsw_config(HnswConfigDiffBuilder::default().on_disk(true)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.HnswConfigDiff;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .setOnDisk(true)
-                            .build())
-                    .build())
-            .setHnswConfig(HnswConfigDiff.newBuilder().setOnDisk(true).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true},
-	hnswConfig: new HnswConfigDiff { OnDisk = true }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-		OnDisk:   qdrant.PtrOf(true),
-	}),
-	HnswConfig: &qdrant.HnswConfigDiff{
-		OnDisk: qdrant.PtrOf(true),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/" >}}
 
 ### Improving Precision
 
@@ -476,159 +66,7 @@ For scenarios requiring both high speed and high precision, keep as much data in
 
 Here is how you can configure scalar quantization for a collection:
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .quantization_config(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .always_ram(true),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setAlwaysRam(true)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine},
-	quantizationConfig: new QuantizationConfig
-	{
-		Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = true }
-	}
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	QuantizationConfig: qdrant.NewQuantizationScalar(&qdrant.ScalarQuantization{
-		Type:      qdrant.QuantizationType_Int8,
-		AlwaysRam: qdrant.PtrOf(true),
-	}),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/" >}}
 
 ### Fine-Tuning Search Parameters
 
@@ -638,118 +76,7 @@ You can adjust search parameters like `hnsw_ef` and `exact` to balance between s
 - `hnsw_ef`: Number of neighbors to visit during search (higher value = better accuracy, slower speed).
 - `exact`: Set to `true` for exact search, which is slower but more accurate. You can use it to compare results of the search with different `hnsw_ef` values versus the ground truth.
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "params": {
-        "hnsw_ef": 128,
-        "exact": false
-    },
-    "limit": 3
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    search_params=models.SearchParams(hnsw_ef=128, exact=False),
-    limit=3,
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    params: {
-        hnsw_ef: 128,
-        exact: false,
-    },
-    limit: 3,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{QueryPointsBuilder, SearchParamsBuilder};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .params(SearchParamsBuilder::default().hnsw_ef(128).exact(false)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setParams(SearchParams.newBuilder().setHnswEf(128).setExact(false).build())
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	searchParams: new SearchParams { HnswEf = 128, Exact = false },
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Params: &qdrant.SearchParams{
-		HnswEf: qdrant.PtrOf(uint64(128)),
-		Exact:  qdrant.PtrOf(false),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-params/" >}}
 
 ## Balancing Latency and Throughput
 
@@ -766,266 +93,16 @@ You can do this by setting the number of segments in the collection to be equal
 
 In this case, each segment will be processed in parallel, and the final result will be obtained faster.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "optimizers_config": {
-        "default_segment_number": 16
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    optimizers_config=models.OptimizersConfigDiff(default_segment_number=16),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  optimizers_config: {
-    default_segment_number: 16,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .optimizers_config(
-                OptimizersConfigDiffBuilder::default().default_segment_number(16),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setOptimizersConfig(
-                OptimizersConfigDiff.newBuilder().setDefaultSegmentNumber(16).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
-	optimizersConfig: new OptimizersConfigDiff { DefaultSegmentNumber = 16 }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{
-		DefaultSegmentNumber: qdrant.PtrOf(uint64(16)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-high-number-of-segments/" >}}
 ### Maximizing Throughput
 
 To maximize throughput, configure Qdrant to use as many cores as possible to process multiple requests in parallel.
 
-To do that, use fewer segments (usually 2) to handle more requests in parallel.
+To do that, use fewer segments (usually 2) of larger size (default 200Mb per segment) to handle more requests in parallel.
 
 Large segments benefit from the size of the index and overall smaller number of vector comparisons required to find the nearest neighbors. However, they will require more time to build the HNSW index.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "optimizers_config": {
-        "default_segment_number": 2
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    optimizers_config=models.OptimizersConfigDiff(default_segment_number=2),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  optimizers_config: {
-    default_segment_number: 2,
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .optimizers_config(
-                OptimizersConfigDiffBuilder::default().default_segment_number(2),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setOptimizersConfig(
-                OptimizersConfigDiff.newBuilder().setDefaultSegmentNumber(2).build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
-	collectionName: "{collection_name}",
-	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
-	optimizersConfig: new OptimizersConfigDiff { DefaultSegmentNumber = 2 }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	OptimizersConfig: &qdrant.OptimizersConfigDiff{
-		DefaultSegmentNumber: qdrant.PtrOf(uint64(2)),
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-large-segments/" >}}
 
 ## Summary
 
diff --git a/qdrant-landing/content/documentation/guides/quantization.md b/qdrant-landing/content/documentation/guides/quantization.md
index 2bac082a3..a779608b5 100644
--- a/qdrant-landing/content/documentation/guides/quantization.md
+++ b/qdrant-landing/content/documentation/guides/quantization.md
@@ -146,171 +146,7 @@ To enable scalar quantization, you need to specify the quantization parameters i
 
 When enabling scalar quantization on an existing collection, use a PATCH request or the corresponding `update_collection` method and omit the vector configuration, as it's already defined.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "quantile": 0.99,
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            quantile=0.99,
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      quantile: 0.99,
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .quantization_config(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .quantile(0.99)
-                    .always_ram(true),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setQuantile(0.99f)
-                            .setAlwaysRam(true)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
- collectionName: "{collection_name}",
- vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
- quantizationConfig: new QuantizationConfig
- {
-  Scalar = new ScalarQuantization
-  {
-   Type = QuantizationType.Int8,
-   Quantile = 0.99f,
-   AlwaysRam = true
-  }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	QuantizationConfig: qdrant.NewQuantizationScalar(
-		&qdrant.ScalarQuantization{
-            Type:      qdrant.QuantizationType_Int8,
-			Quantile:  qdrant.PtrOf(float32(0.99)),
-			AlwaysRam: qdrant.PtrOf(true),
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-scalar-quantization-params/" >}}
 
 There are 3 parameters that you can specify in the `quantization_config` section:
 
@@ -335,146 +171,7 @@ To enable binary quantization, you need to specify the quantization parameters i
 
 When enabling binary quantization on an existing collection, use a PATCH request or the corresponding `update_collection` method and omit the vector configuration, as it's already defined.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 1536,
-      "distance": "Cosine"
-    },
-    "quantization_config": {
-        "binary": {
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=1536, distance=models.Distance.COSINE),
-    quantization_config=models.BinaryQuantization(
-        binary=models.BinaryQuantizationConfig(
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 1536,
-    distance: "Cosine",
-  },
-  quantization_config: {
-    binary: {
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    BinaryQuantizationBuilder, CreateCollectionBuilder, Distance, VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(1536, Distance::Cosine))
-            .quantization_config(BinaryQuantizationBuilder::new(true)),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.BinaryQuantization;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(1536)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setBinary(BinaryQuantization.newBuilder().setAlwaysRam(true).build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
- collectionName: "{collection_name}",
- vectorsConfig: new VectorParams { Size = 1536, Distance = Distance.Cosine },
- quantizationConfig: new QuantizationConfig
- {
-  Binary = new BinaryQuantization { AlwaysRam = true }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     1536,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	QuantizationConfig: qdrant.NewQuantizationBinary(
-		&qdrant.BinaryQuantization{
-			AlwaysRam: qdrant.PtrOf(true),
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-binary-quantization/" >}}
 
 `always_ram` - whether to keep quantized vectors always cached in RAM or not. By default, quantized vectors are loaded in the same way as the original vectors.
 However, in some setups you might want to keep quantized vectors in RAM to speed up the search process.
@@ -487,158 +184,7 @@ To enable product quantization, you need to specify the quantization parameters
 
 When enabling product quantization on an existing collection, use a PATCH request or the corresponding `update_collection` method and omit the vector configuration, as it's already defined.
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine"
-    },
-    "quantization_config": {
-        "product": {
-            "compression": "x16",
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
-    quantization_config=models.ProductQuantization(
-        product=models.ProductQuantizationConfig(
-            compression=models.CompressionRatio.X16,
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-  },
-  quantization_config: {
-    product: {
-      compression: "x16",
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CompressionRatio, CreateCollectionBuilder, Distance, ProductQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
-            .quantization_config(
-                ProductQuantizationBuilder::new(CompressionRatio::X16.into()).always_ram(true),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CompressionRatio;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.ProductQuantization;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setProduct(
-                        ProductQuantization.newBuilder()
-                            .setCompression(CompressionRatio.x16)
-                            .setAlwaysRam(true)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
- collectionName: "{collection_name}",
- vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
- quantizationConfig: new QuantizationConfig
- {
-  Product = new ProductQuantization { Compression = CompressionRatio.X16, AlwaysRam = true }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-	}),
-	QuantizationConfig: qdrant.NewQuantizationProduct(
-		&qdrant.ProductQuantization{
-			Compression: qdrant.CompressionRatio_x16,
-			AlwaysRam:   qdrant.PtrOf(true),
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/with-product-quantization/" >}}
 
 There are two parameters that you can specify in the `quantization_config` section:
 
@@ -656,158 +202,7 @@ Qdrant will automatically use quantized vectors if they are available.
 
 However, there are a few options that you can use to control the search process:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "params": {
-        "quantization": {
-            "ignore": false,
-            "rescore": true,
-            "oversampling": 2.0
-        }
-    },
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    search_params=models.SearchParams(
-        quantization=models.QuantizationSearchParams(
-            ignore=False,
-            rescore=True,
-            oversampling=2.0,
-        )
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    params: {
-        quantization: {
-            ignore: false,
-            rescore: true,
-            oversampling: 2.0,
-        },
-    },
-    limit: 10,
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-    
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(10)
-            .params(
-                SearchParamsBuilder::default().quantization(
-                    QuantizationSearchParamsBuilder::default()
-                        .ignore(false)
-                        .rescore(true)
-                        .oversampling(2.0),
-                ),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QuantizationSearchParams;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setParams(
-                        SearchParams.newBuilder()
-                                .setQuantization(
-                                        QuantizationSearchParams.newBuilder()
-                                                .setIgnore(false)
-                                                .setRescore(true)
-                                                .setOversampling(2.0)
-                                                .build())
-                                .build())
-                .setLimit(10)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	searchParams: new SearchParams
-	{
-		Quantization = new QuantizationSearchParams
-		{
-			Ignore = false,
-			Rescore = true,
-			Oversampling = 2.0
-		}
-	},
-	limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Params: &qdrant.SearchParams{
-		Quantization: &qdrant.QuantizationSearchParams{
-			Ignore:       qdrant.PtrOf(false),
-			Rescore:      qdrant.PtrOf(true),
-			Oversampling: qdrant.PtrOf(2.0),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-quantization-oversampling/" >}}
 
 `ignore` - Toggle whether to ignore quantized vectors during the search process. By default, Qdrant will use quantized vectors if they are available.
 
@@ -831,136 +226,7 @@ The fastest way to understand the impact of quantization on the search quality i
 
 In order to disable quantization, you can set `ignore` to `true` in the search request:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "params": {
-        "quantization": {
-            "ignore": true
-        }
-    },
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    search_params=models.SearchParams(
-        quantization=models.QuantizationSearchParams(
-            ignore=True,
-        )
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    params: {
-        quantization: {
-            ignore: true,
-        },
-    },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .params(
-                SearchParamsBuilder::default()
-                    .quantization(QuantizationSearchParamsBuilder::default().ignore(true)),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QuantizationSearchParams;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setParams(
-                        SearchParams.newBuilder()
-                                .setQuantization(
-                                        QuantizationSearchParams.newBuilder().setIgnore(true).build())
-                                .build())
-                .setLimit(10)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	searchParams: new SearchParams
-	{
-		Quantization = new QuantizationSearchParams { Ignore = true }
-	},
-	limit: 10
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Params: &qdrant.SearchParams{
-		Quantization: &qdrant.QuantizationSearchParams{
-			Ignore: qdrant.PtrOf(false),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-ignored-quantization/" >}}
 
 - **Adjust the quantile parameter**: The quantile parameter in scalar quantization determines the quantization bounds.
 By setting it to a value lower than 1.0, you can exclude extreme values (outliers) from the quantization bounds.
@@ -981,299 +247,14 @@ There are 3 possible modes to place storage of vectors within the qdrant collect
 
 This mode is enabled by setting `always_ram` to `true` in the quantization config while using memmap storage:
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine",
-      "on_disk": true
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "always_ram": true
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            always_ram=True,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-    on_disk: true,
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      always_ram: true,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
-            .quantization_config(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .always_ram(true),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .setOnDisk(true)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setAlwaysRam(true)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
- collectionName: "{collection_name}",
- vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true},
- quantizationConfig: new QuantizationConfig
- {
-  Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = true }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-		OnDisk:   qdrant.PtrOf(true),
-	}),
-	QuantizationConfig: qdrant.NewQuantizationScalar(
-		&qdrant.ScalarQuantization{
-			Type:      qdrant.QuantizationType_Int8,
-			AlwaysRam: qdrant.PtrOf(true),
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/" >}}
 
 In this scenario, the number of disk reads may play a significant role in the search speed.
 In a system with high disk latency, the re-scoring step may become a bottleneck.
 
 Consider disabling `rescore` to improve the search speed:
 
-```http
-POST /collections/{collection_name}/points/query
-{
-    "query": [0.2, 0.1, 0.9, 0.7],
-    "params": {
-        "quantization": {
-            "rescore": false
-        }
-    },
-    "limit": 10
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.query_points(
-    collection_name="{collection_name}",
-    query=[0.2, 0.1, 0.9, 0.7],
-    search_params=models.SearchParams(
-        quantization=models.QuantizationSearchParams(rescore=False)
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.query("{collection_name}", {
-    query: [0.2, 0.1, 0.9, 0.7],
-    params: {
-        quantization: {
-            rescore: false,
-        },
-    },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .query(
-        QueryPointsBuilder::new("{collection_name}")
-            .query(vec![0.2, 0.1, 0.9, 0.7])
-            .limit(3)
-            .params(
-                SearchParamsBuilder::default()
-                    .quantization(QuantizationSearchParamsBuilder::default().rescore(false)),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Points.QuantizationSearchParams;
-import io.qdrant.client.grpc.Points.QueryPoints;
-import io.qdrant.client.grpc.Points.SearchParams;
-
-import static io.qdrant.client.QueryFactory.nearest;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client.queryAsync(
-        QueryPoints.newBuilder()
-                .setCollectionName("{collection_name}")
-                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
-                .setParams(
-                        SearchParams.newBuilder()
-                                .setQuantization(
-                                        QuantizationSearchParams.newBuilder().setRescore(false).build())
-                                .build())
-                .setLimit(3)
-                .build())
-        .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.QueryAsync(
-	collectionName: "{collection_name}",
-	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
-	searchParams: new SearchParams
-	{
-		Quantization = new QuantizationSearchParams { Rescore = false }
-	},
-	limit: 3
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.Query(context.Background(), &qdrant.QueryPoints{
-	CollectionName: "{collection_name}",
-	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
-	Params: &qdrant.SearchParams{
-		Quantization: &qdrant.QuantizationSearchParams{
-			Rescore: qdrant.PtrOf(false),
-		},
-	},
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/query-points/with-disabled-rescoring/" >}}
 
 - **All on Disk** - all vectors, original and quantized, are stored on disk. This mode allows to achieve the smallest memory footprint, but at the cost of the search speed.
 
@@ -1281,162 +262,4 @@ It is recommended to use this mode if you have a large collection and fast stora
 
 This mode is enabled by setting `always_ram` to `false` in the quantization config while using mmap storage:
 
-```http
-PUT /collections/{collection_name}
-{
-    "vectors": {
-      "size": 768,
-      "distance": "Cosine",
-      "on_disk": true
-    },
-    "quantization_config": {
-        "scalar": {
-            "type": "int8",
-            "always_ram": false
-        }
-    }
-}
-```
-
-```python
-from qdrant_client import QdrantClient, models
-
-client = QdrantClient(url="http://localhost:6333")
-
-client.create_collection(
-    collection_name="{collection_name}",
-    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
-    quantization_config=models.ScalarQuantization(
-        scalar=models.ScalarQuantizationConfig(
-            type=models.ScalarType.INT8,
-            always_ram=False,
-        ),
-    ),
-)
-```
-
-```typescript
-import { QdrantClient } from "@qdrant/js-client-rest";
-
-const client = new QdrantClient({ host: "localhost", port: 6333 });
-
-client.createCollection("{collection_name}", {
-  vectors: {
-    size: 768,
-    distance: "Cosine",
-    on_disk: true,
-  },
-  quantization_config: {
-    scalar: {
-      type: "int8",
-      always_ram: false,
-    },
-  },
-});
-```
-
-```rust
-use qdrant_client::qdrant::{
-    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
-    VectorParamsBuilder,
-};
-use qdrant_client::Qdrant;
-
-let client = Qdrant::from_url("http://localhost:6334").build()?;
-
-client
-    .create_collection(
-        CreateCollectionBuilder::new("{collection_name}")
-            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
-            .quantization_config(
-                ScalarQuantizationBuilder::default()
-                    .r#type(QuantizationType::Int8.into())
-                    .always_ram(false),
-            ),
-    )
-    .await?;
-```
-
-```java
-import io.qdrant.client.QdrantClient;
-import io.qdrant.client.QdrantGrpcClient;
-import io.qdrant.client.grpc.Collections.CreateCollection;
-import io.qdrant.client.grpc.Collections.Distance;
-import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
-import io.qdrant.client.grpc.Collections.QuantizationConfig;
-import io.qdrant.client.grpc.Collections.QuantizationType;
-import io.qdrant.client.grpc.Collections.ScalarQuantization;
-import io.qdrant.client.grpc.Collections.VectorParams;
-import io.qdrant.client.grpc.Collections.VectorsConfig;
-
-QdrantClient client =
-    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
-
-client
-    .createCollectionAsync(
-        CreateCollection.newBuilder()
-            .setCollectionName("{collection_name}")
-            .setVectorsConfig(
-                VectorsConfig.newBuilder()
-                    .setParams(
-                        VectorParams.newBuilder()
-                            .setSize(768)
-                            .setDistance(Distance.Cosine)
-                            .setOnDisk(true)
-                            .build())
-                    .build())
-            .setQuantizationConfig(
-                QuantizationConfig.newBuilder()
-                    .setScalar(
-                        ScalarQuantization.newBuilder()
-                            .setType(QuantizationType.Int8)
-                            .setAlwaysRam(false)
-                            .build())
-                    .build())
-            .build())
-    .get();
-```
-
-```csharp
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-
-var client = new QdrantClient("localhost", 6334);
-
-await client.CreateCollectionAsync(
- collectionName: "{collection_name}",
- vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true},
- quantizationConfig: new QuantizationConfig
- {
-  Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = false }
- }
-);
-```
-
-```go
-import (
-	"context"
-
-	"github.com/qdrant/go-client/qdrant"
-)
-
-client, err := qdrant.NewClient(&qdrant.Config{
-	Host: "localhost",
-	Port: 6334,
-})
-
-client.CreateCollection(context.Background(), &qdrant.CreateCollection{
-	CollectionName: "{collection_name}",
-	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
-		Size:     768,
-		Distance: qdrant.Distance_Cosine,
-		OnDisk:   qdrant.PtrOf(true),
-	}),
-	QuantizationConfig: qdrant.NewQuantizationScalar(
-		&qdrant.ScalarQuantization{
-			Type:      qdrant.QuantizationType_Int8,
-			AlwaysRam: qdrant.PtrOf(false),
-		},
-	),
-})
-```
+{{< code-snippet path="/documentation/headless/snippets/create-collection/quantization-on-disk/" >}}
diff --git a/qdrant-landing/content/documentation/headless/_index.md b/qdrant-landing/content/documentation/headless/_index.md
new file mode 100644
index 000000000..9973c5a34
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/_index.md
@@ -0,0 +1,11 @@
+---
+build:
+  list: never
+  publishResources: false
+  render: never
+cascade:
+- build:
+    list: never
+    publishResources: false
+    render: never
+---
diff --git a/qdrant-landing/content/documentation/headless/snippets/_index.md b/qdrant-landing/content/documentation/headless/snippets/_index.md
new file mode 100644
index 000000000..5a8cb8388
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/_index.md
@@ -0,0 +1,12 @@
+---
+snippetsOrder:
+- json
+- http
+- bash
+- python
+- typescript
+- rust
+- java
+- csharp
+- go
+---
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/_description.md
new file mode 100644
index 000000000..952e83648
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/_description.md
@@ -0,0 +1 @@
+With this code snippet, you can perform batch operations on points like upserting, updating vectors, deleting vectors, setting, overwriting, deleting, and clearing payload data associated with points. The operations include inserting, updating, and deleting points along with their vectors and payload. Each operation is executed in order specified in the request payload.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/http.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/http.md
new file mode 100644
index 000000000..a3833579f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/http.md
@@ -0,0 +1,63 @@
+```http
+POST /collections/{collection_name}/points/batch
+{
+    "operations": [
+        {
+            "upsert": {
+                "points": [
+                    {
+                        "id": 1,
+                        "vector": [1.0, 2.0, 3.0, 4.0],
+                        "payload": {}
+                    }
+                ]
+            }
+        },
+        {
+            "update_vectors": {
+                "points": [
+                    {
+                        "id": 1,
+                        "vector": [1.0, 2.0, 3.0, 4.0]
+                    }
+                ]
+            }
+        },
+        {
+            "delete_vectors": {
+                "points": [1],
+                "vector": [""]
+            }
+        },
+        {
+            "overwrite_payload": {
+                "payload": {
+                    "test_payload": "1"
+                },
+                "points": [1]
+            }
+        },
+        {
+            "set_payload": {
+                "payload": {
+                    "test_payload_2": "2",
+                    "test_payload_3": "3"
+                },
+                "points": [1]
+            }
+        },
+        {
+            "delete_payload": {
+                "keys": ["test_payload_2"],
+                "points": [1]
+            }
+        },
+        {
+            "clear_payload": {
+                "points": [1]
+            }
+        },
+        {"delete": {"points": [1]}}
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/java.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/java.md
new file mode 100644
index 000000000..b0f2cabdd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/java.md
@@ -0,0 +1,107 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.grpc.Points.PointStruct;
+import io.qdrant.client.grpc.Points.PointVectors;
+import io.qdrant.client.grpc.Points.PointsIdsList;
+import io.qdrant.client.grpc.Points.PointsSelector;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.ClearPayload;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeletePayload;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeletePoints;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.DeleteVectors;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.PointStructList;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.SetPayload;
+import io.qdrant.client.grpc.Points.PointsUpdateOperation.UpdateVectors;
+import io.qdrant.client.grpc.Points.VectorsSelector;
+
+client
+    .batchUpdateAsync(
+        "{collection_name}",
+        List.of(
+            PointsUpdateOperation.newBuilder()
+                .setUpsert(
+                    PointStructList.newBuilder()
+                        .addPoints(
+                            PointStruct.newBuilder()
+                                .setId(id(1))
+                                .setVectors(vectors(1.0f, 2.0f, 3.0f, 4.0f))
+                                .build())
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setUpdateVectors(
+                    UpdateVectors.newBuilder()
+                        .addPoints(
+                            PointVectors.newBuilder()
+                                .setId(id(1))
+                                .setVectors(vectors(1.0f, 2.0f, 3.0f, 4.0f))
+                                .build())
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setDeleteVectors(
+                    DeleteVectors.newBuilder()
+                        .setPointsSelector(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .setVectors(VectorsSelector.newBuilder().addNames("").build())
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setOverwritePayload(
+                    SetPayload.newBuilder()
+                        .setPointsSelector(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .putAllPayload(Map.of("test_payload", value(1)))
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setSetPayload(
+                    SetPayload.newBuilder()
+                        .setPointsSelector(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .putAllPayload(
+                            Map.of("test_payload_2", value(2), "test_payload_3", value(3)))
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setDeletePayload(
+                    DeletePayload.newBuilder()
+                        .setPointsSelector(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .addKeys("test_payload_2")
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setClearPayload(
+                    ClearPayload.newBuilder()
+                        .setPoints(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .build())
+                .build(),
+            PointsUpdateOperation.newBuilder()
+                .setDeletePoints(
+                    DeletePoints.newBuilder()
+                        .setPoints(
+                            PointsSelector.newBuilder()
+                                .setPoints(PointsIdsList.newBuilder().addIds(id(1)).build())
+                                .build())
+                        .build())
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/python.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/python.md
new file mode 100644
index 000000000..f80ea6898
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/python.md
@@ -0,0 +1,51 @@
+```python
+client.batch_update_points(
+    collection_name="{collection_name}",
+    update_operations=[
+        models.UpsertOperation(
+            upsert=models.PointsList(
+                points=[
+                    models.PointStruct(
+                        id=1,
+                        vector=[1.0, 2.0, 3.0, 4.0],
+                        payload={},
+                    ),
+                ]
+            )
+        ),
+        models.UpdateVectorsOperation(
+            update_vectors=models.UpdateVectors(
+                points=[
+                    models.PointVectors(
+                        id=1,
+                        vector=[1.0, 2.0, 3.0, 4.0],
+                    )
+                ]
+            )
+        ),
+        models.DeleteVectorsOperation(
+            delete_vectors=models.DeleteVectors(points=[1], vector=[""])
+        ),
+        models.OverwritePayloadOperation(
+            overwrite_payload=models.SetPayload(
+                payload={"test_payload": 1},
+                points=[1],
+            )
+        ),
+        models.SetPayloadOperation(
+            set_payload=models.SetPayload(
+                payload={
+                    "test_payload_2": 2,
+                    "test_payload_3": 3,
+                },
+                points=[1],
+            )
+        ),
+        models.DeletePayloadOperation(
+            delete_payload=models.DeletePayload(keys=["test_payload_2"], points=[1])
+        ),
+        models.ClearPayloadOperation(clear_payload=models.PointIdsList(points=[1])),
+        models.DeleteOperation(delete=models.PointIdsList(points=[1])),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/rust.md
new file mode 100644
index 000000000..a361b5170
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/rust.md
@@ -0,0 +1,87 @@
+```rust
+use std::collections::HashMap;
+
+use qdrant_client::qdrant::{
+    points_update_operation::{
+        ClearPayload, DeletePayload, DeletePoints, DeleteVectors, Operation, OverwritePayload,
+        PointStructList, SetPayload, UpdateVectors,
+    },
+    PointStruct, PointVectors, PointsUpdateOperation, UpdateBatchPointsBuilder, VectorsSelector,
+};
+use qdrant_client::Payload;
+
+client
+    .update_points_batch(
+        UpdateBatchPointsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointsUpdateOperation {
+                    operation: Some(Operation::Upsert(PointStructList {
+                        points: vec![PointStruct::new(
+                            1,
+                            vec![1.0, 2.0, 3.0, 4.0],
+                            Payload::default(),
+                        )],
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::UpdateVectors(UpdateVectors {
+                        points: vec![PointVectors {
+                            id: Some(1.into()),
+                            vectors: Some(vec![1.0, 2.0, 3.0, 4.0].into()),
+                        }],
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::DeleteVectors(DeleteVectors {
+                        points_selector: Some(vec![1.into()].into()),
+                        vectors: Some(VectorsSelector {
+                            names: vec!["".into()],
+                        }),
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::OverwritePayload(OverwritePayload {
+                        points_selector: Some(vec![1.into()].into()),
+                        payload: HashMap::from([("test_payload".to_string(), 1.into())]),
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::SetPayload(SetPayload {
+                        points_selector: Some(vec![1.into()].into()),
+                        payload: HashMap::from([
+                            ("test_payload_2".to_string(), 2.into()),
+                            ("test_payload_3".to_string(), 3.into()),
+                        ]),
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::DeletePayload(DeletePayload {
+                        points_selector: Some(vec![1.into()].into()),
+                        keys: vec!["test_payload_2".to_string()],
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::ClearPayload(ClearPayload {
+                        points: Some(vec![1.into()].into()),
+                        ..Default::default()
+                    })),
+                },
+                PointsUpdateOperation {
+                    operation: Some(Operation::DeletePoints(DeletePoints {
+                        points: Some(vec![1.into()].into()),
+                        ..Default::default()
+                    })),
+                },
+            ],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/typescript.md
new file mode 100644
index 000000000..40f3034cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/batch-update-points/basic/typescript.md
@@ -0,0 +1,66 @@
+```typescript
+client.batchUpdate("{collection_name}", {
+  operations: [
+    {
+      upsert: {
+        points: [
+          {
+            id: 1,
+            vector: [1.0, 2.0, 3.0, 4.0],
+            payload: {},
+          },
+        ],
+      },
+    },
+    {
+      update_vectors: {
+        points: [
+          {
+            id: 1,
+            vector: [1.0, 2.0, 3.0, 4.0],
+          },
+        ],
+      },
+    },
+    {
+      delete_vectors: {
+        points: [1],
+        vector: [""],
+      },
+    },
+    {
+      overwrite_payload: {
+        payload: {
+          test_payload: 1,
+        },
+        points: [1],
+      },
+    },
+    {
+      set_payload: {
+        payload: {
+          test_payload_2: 2,
+          test_payload_3: 3,
+        },
+        points: [1],
+      },
+    },
+    {
+      delete_payload: {
+        keys: ["test_payload_2"],
+        points: [1],
+      },
+    },
+    {
+      clear_payload: {
+        points: [1],
+      },
+    },
+    {
+      delete: {
+        points: [1],
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/_description.md
new file mode 100644
index 000000000..5cfaf1bc8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a feature to check if a collection exists by making a GET request to a specified endpoint that includes the collection name. This functionality is available starting from version 1.8.0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/bash.md
new file mode 100644
index 000000000..e4728d732
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X GET http://localhost:6333/collections/{collection_name}/exists
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/csharp.md
new file mode 100644
index 000000000..ffcf6ad93
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.CollectionExistsAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/go.md
new file mode 100644
index 000000000..5c516af60
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/go.md
@@ -0,0 +1,5 @@
+```go
+import "context"
+
+client.CollectionExists(context.Background(), "my_collection")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/http.md
new file mode 100644
index 000000000..c07315765
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/http.md
@@ -0,0 +1,3 @@
+```http
+GET http://localhost:6333/collections/{collection_name}/exists
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/java.md
new file mode 100644
index 000000000..beca91bb3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/java.md
@@ -0,0 +1,3 @@
+```java
+client.collectionExistsAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/python.md
new file mode 100644
index 000000000..8a1dd8b06
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/python.md
@@ -0,0 +1,3 @@
+```python
+client.collection_exists(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/rust.md
new file mode 100644
index 000000000..7bce52e91
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/rust.md
@@ -0,0 +1,3 @@
+```rust
+client.collection_exists("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/typescript.md
new file mode 100644
index 000000000..d0e22a2d3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/check-collection-exists/simple/typescript.md
@@ -0,0 +1,3 @@
+```typescript
+client.collectionExists("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/_description.md
new file mode 100644
index 000000000..7b4b2505a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a functionality to clear payload keys from specific points by providing a list of point identifiers.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/csharp.md
new file mode 100644
index 000000000..9030d1f80
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ClearPayloadAsync(collectionName: "{collection_name}", ids: new ulong[] { 0, 3, 100 });
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/go.md
new file mode 100644
index 000000000..c54716515
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.ClearPayload(context.Background(), &qdrant.ClearPayloadPoints{
+    CollectionName: "{collection_name}",
+    Points: qdrant.NewPointsSelector(
+        qdrant.NewIDNum(0),
+        qdrant.NewIDNum(3)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/http.md
new file mode 100644
index 000000000..57384e02b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/http.md
@@ -0,0 +1,6 @@
+```http
+POST /collections/{collection_name}/points/payload/clear
+{
+    "points": [0, 3, 100]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/java.md
new file mode 100644
index 000000000..cb72c15f4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/java.md
@@ -0,0 +1,9 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+
+client
+    .clearPayloadAsync("{collection_name}", List.of(id(0), id(3), id(100)), true, null, null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/python.md
new file mode 100644
index 000000000..fb8c23507
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/python.md
@@ -0,0 +1,6 @@
+```python
+client.clear_payload(
+    collection_name="{collection_name}",
+    points_selector=[0, 3, 100],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/rust.md
new file mode 100644
index 000000000..39b59320b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{ClearPayloadPointsBuilder, PointsIdsList};
+
+client
+    .clear_payload(
+        ClearPayloadPointsBuilder::new("{collection_name}")
+            .points(PointsIdsList {
+                ids: vec![0.into(), 3.into(), 10.into()],
+            })
+            .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/typescript.md
new file mode 100644
index 000000000..a3f684154
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/clear-payload/simple/typescript.md
@@ -0,0 +1,5 @@
+```typescript
+client.clearPayload("{collection_name}", {
+  points: [0, 3, 100],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/_description.md
new file mode 100644
index 000000000..f8f4690e9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/_description.md
@@ -0,0 +1 @@
+This code snippet creates an alias named "production_collection" for the collection called "example_collection".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/bash.md
new file mode 100644
index 000000000..3f7d85ed6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/bash.md
@@ -0,0 +1,14 @@
+```bash
+curl -X POST http://localhost:6333/collections/aliases \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "actions": [
+        {
+            "create_alias": {
+                "collection_name": "example_collection",
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/csharp.md
new file mode 100644
index 000000000..6073379e6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.CreateAliasAsync(aliasName: "production_collection", collectionName: "example_collection");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/go.md
new file mode 100644
index 000000000..baaf8a204
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/go.md
@@ -0,0 +1,5 @@
+```go
+import "context"
+
+client.CreateAlias(context.Background(), "production_collection", "example_collection")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/http.md
new file mode 100644
index 000000000..f6d4a45a7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/aliases
+{
+    "actions": [
+        {
+            "create_alias": {
+                "collection_name": "example_collection",
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/java.md
new file mode 100644
index 000000000..69a4572ee
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/java.md
@@ -0,0 +1,3 @@
+```java
+client.createAliasAsync("production_collection", "example_collection").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/python.md
new file mode 100644
index 000000000..a9addb742
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/python.md
@@ -0,0 +1,11 @@
+```python
+client.update_collection_aliases(
+    change_aliases_operations=[
+        models.CreateAliasOperation(
+            create_alias=models.CreateAlias(
+                collection_name="example_collection", alias_name="production_collection"
+            )
+        )
+    ]
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/rust.md
new file mode 100644
index 000000000..8c0317606
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/rust.md
@@ -0,0 +1,10 @@
+```rust
+use qdrant_client::qdrant::CreateAliasBuilder;
+
+client
+    .create_alias(CreateAliasBuilder::new(
+        "example_collection",
+        "production_collection",
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/typescript.md
new file mode 100644
index 000000000..e86f2ec24
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/create/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+client.updateCollectionAliases({
+  actions: [
+    {
+      create_alias: {
+        collection_name: "example_collection",
+        alias_name: "production_collection",
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/_description.md
new file mode 100644
index 000000000..7d65a8adb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/_description.md
@@ -0,0 +1 @@
+This code snippet is aiming to perform an action of removing an alias named "production_collection" within a collection alias in a system.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/bash.md
new file mode 100644
index 000000000..668e59c9c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/bash.md
@@ -0,0 +1,13 @@
+```bash
+curl -X POST http://localhost:6333/collections/aliases \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "actions": [
+        {
+            "delete_alias": {
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/csharp.md
new file mode 100644
index 000000000..b35268043
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.DeleteAliasAsync("production_collection");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/go.md
new file mode 100644
index 000000000..f258aacde
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/go.md
@@ -0,0 +1,5 @@
+```go
+import "context"
+
+client.DeleteAlias(context.Background(), "production_collection")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/http.md
new file mode 100644
index 000000000..f9d480315
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/aliases
+{
+    "actions": [
+        {
+            "delete_alias": {
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/java.md
new file mode 100644
index 000000000..d9d9f5847
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/java.md
@@ -0,0 +1,3 @@
+```java
+client.deleteAliasAsync("production_collection").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/python.md
new file mode 100644
index 000000000..0f0c689ff
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/python.md
@@ -0,0 +1,9 @@
+```python
+client.update_collection_aliases(
+    change_aliases_operations=[
+        models.DeleteAliasOperation(
+            delete_alias=models.DeleteAlias(alias_name="production_collection")
+        ),
+    ]
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/rust.md
new file mode 100644
index 000000000..eda7ce43e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/rust.md
@@ -0,0 +1,3 @@
+```rust
+client.delete_alias("production_collection").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/typescript.md
new file mode 100644
index 000000000..0fc37d6bc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/delete/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+client.updateCollectionAliases({
+  actions: [
+    {
+      delete_alias: {
+        alias_name: "production_collection",
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/_description.md
new file mode 100644
index 000000000..26c1a64f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/_description.md
@@ -0,0 +1 @@
+This code snippet is used to retrieve all aliases from a collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/bash.md
new file mode 100644
index 000000000..968c7b89f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X GET http://localhost:6333/aliases
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/csharp.md
new file mode 100644
index 000000000..c44ea6d43
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ListAliasesAsync();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/go.md
new file mode 100644
index 000000000..efd32e147
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.ListAliases(context.Background())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/http.md
new file mode 100644
index 000000000..1795b3e4e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/http.md
@@ -0,0 +1,3 @@
+```http
+GET /aliases
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/java.md
new file mode 100644
index 000000000..9e01c06c0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.listAliasesAsync().get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/python.md
new file mode 100644
index 000000000..673a7e3cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.get_aliases()
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/rust.md
new file mode 100644
index 000000000..fdd38c8b6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.list_aliases().await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/typescript.md
new file mode 100644
index 000000000..9f8763f86
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list-all/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.getAliases();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/_description.md
new file mode 100644
index 000000000..9552990cc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/_description.md
@@ -0,0 +1 @@
+This code retrieves a list of aliases associated with a specific collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/bash.md
new file mode 100644
index 000000000..7200293ae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X GET http://localhost:6333/collections/{collection_name}/aliases
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/csharp.md
new file mode 100644
index 000000000..043f343fa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ListCollectionAliasesAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/go.md
new file mode 100644
index 000000000..1effe1c30
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.ListCollectionAliases(context.Background(), "{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/http.md
new file mode 100644
index 000000000..2e4a92363
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections/{collection_name}/aliases
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/java.md
new file mode 100644
index 000000000..5e316a2b8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.listCollectionAliasesAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/python.md
new file mode 100644
index 000000000..576ebd89f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.get_collection_aliases(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/rust.md
new file mode 100644
index 000000000..451b41fca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.list_collection_aliases("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/typescript.md
new file mode 100644
index 000000000..e0435fb38
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/list/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.getCollectionAliases("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/_description.md
new file mode 100644
index 000000000..df4a48f64
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/_description.md
@@ -0,0 +1 @@
+Perform atomic alias actions to switch collections. In this scenario, there is a POST request made to manage aliases. The code snippet demonstrates a sequence of actions where an alias named "production_collection" is deleted, and then a new alias with the same name is created for the "example_collection". This allows for switching between collections efficiently.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/bash.md
new file mode 100644
index 000000000..e294d9c09
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/bash.md
@@ -0,0 +1,19 @@
+```bash
+curl -X POST http://localhost:6333/collections/aliases \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "actions": [
+        {
+            "delete_alias": {
+                "alias_name": "production_collection"
+            }
+        },
+        {
+            "create_alias": {
+                "collection_name": "example_collection",
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/csharp.md
new file mode 100644
index 000000000..702d90caf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/csharp.md
@@ -0,0 +1,4 @@
+```csharp
+await client.DeleteAliasAsync("production_collection");
+await client.CreateAliasAsync(aliasName: "production_collection", collectionName: "example_collection");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/go.md
new file mode 100644
index 000000000..f60f446ab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/go.md
@@ -0,0 +1,6 @@
+```go
+import "context"
+
+client.DeleteAlias(context.Background(), "production_collection")
+client.CreateAlias(context.Background(), "production_collection", "example_collection")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/http.md
new file mode 100644
index 000000000..a2dd57565
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/http.md
@@ -0,0 +1,18 @@
+```http
+POST /collections/aliases
+{
+    "actions": [
+        {
+            "delete_alias": {
+                "alias_name": "production_collection"
+            }
+        },
+        {
+            "create_alias": {
+                "collection_name": "example_collection",
+                "alias_name": "production_collection"
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/java.md
new file mode 100644
index 000000000..adebec985
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/java.md
@@ -0,0 +1,4 @@
+```java
+client.deleteAliasAsync("production_collection").get();
+client.createAliasAsync("production_collection", "example_collection").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/python.md
new file mode 100644
index 000000000..cda229ffa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/python.md
@@ -0,0 +1,14 @@
+```python
+client.update_collection_aliases(
+    change_aliases_operations=[
+        models.DeleteAliasOperation(
+            delete_alias=models.DeleteAlias(alias_name="production_collection")
+        ),
+        models.CreateAliasOperation(
+            create_alias=models.CreateAlias(
+                collection_name="example_collection", alias_name="production_collection"
+            )
+        ),
+    ]
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/rust.md
new file mode 100644
index 000000000..dffac9ef7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::CreateAliasBuilder;
+
+client.delete_alias("production_collection").await?;
+client
+    .create_alias(CreateAliasBuilder::new(
+        "example_collection",
+        "production_collection",
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/typescript.md
new file mode 100644
index 000000000..08773dd8a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-aliases/switch/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+client.updateCollectionAliases({
+  actions: [
+    {
+      delete_alias: {
+        alias_name: "production_collection",
+      },
+    },
+    {
+      create_alias: {
+        collection_name: "example_collection",
+        alias_name: "production_collection",
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/_description.md
new file mode 100644
index 000000000..4d82b8211
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a feature where you can retrieve information about an existing collection in order to understand how the points are distributed and indexed within it.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/bash.md
new file mode 100644
index 000000000..abdb5556c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X GET http://localhost:6333/collections/{collection_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/csharp.md
new file mode 100644
index 000000000..b1bdd8c92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.GetCollectionInfoAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/go.md
new file mode 100644
index 000000000..231fc8800
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/go.md
@@ -0,0 +1,5 @@
+```go
+import "context"
+
+client.GetCollectionInfo(context.Background(), "{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/http.md
new file mode 100644
index 000000000..e35a7d610
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections/{collection_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/java.md
new file mode 100644
index 000000000..262eabac5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/java.md
@@ -0,0 +1,3 @@
+```java
+client.getCollectionInfoAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/python.md
new file mode 100644
index 000000000..ea8b827c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/python.md
@@ -0,0 +1,3 @@
+```python
+client.get_collection(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/rust.md
new file mode 100644
index 000000000..467eab36d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/rust.md
@@ -0,0 +1,3 @@
+```rust
+client.collection_info("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/typescript.md
new file mode 100644
index 000000000..090f23c7b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/collection-info/simple/typescript.md
@@ -0,0 +1,3 @@
+```typescript
+client.getCollection("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/_description.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/_description.md
new file mode 100644
index 000000000..ff2e48eaa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a POST request to count points based on specific filter conditions within a collection. The filter criteria include checking for points with a key "color" that matches the value "red" precisely. By setting the "exact" parameter to true, the count will consider only exact matches. This functionality is helpful for scenarios such as evaluating result sizes for faceted search, determining pagination numbers, and debugging query performance.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/csharp.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/csharp.md
new file mode 100644
index 000000000..35d9a53ad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CountAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("color", "red"),
+	exact: true
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/go.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/go.md
new file mode 100644
index 000000000..39dc326d2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Count(context.Background(), &qdrant.CountPoints{
+	CollectionName: "midlib",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/http.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/http.md
new file mode 100644
index 000000000..2dfaabedb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/http.md
@@ -0,0 +1,16 @@
+```http
+POST /collections/{collection_name}/points/count
+{
+    "filter": {
+        "must": [
+            {
+                "key": "color",
+                "match": {
+                    "value": "red"
+                }
+            }
+        ]
+    },
+    "exact": true
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/java.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/java.md
new file mode 100644
index 000000000..eadaec18f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/java.md
@@ -0,0 +1,12 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+
+client
+    .countAsync(
+        "{collection_name}",
+        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
+        true)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/python.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/python.md
new file mode 100644
index 000000000..4aa0853dd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/python.md
@@ -0,0 +1,11 @@
+```python
+client.count(
+    collection_name="{collection_name}",
+    count_filter=models.Filter(
+        must=[
+            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
+        ]
+    ),
+    exact=True,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/rust.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/rust.md
new file mode 100644
index 000000000..a323ad471
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::qdrant::{Condition, CountPointsBuilder, Filter};
+
+client
+    .count(
+        CountPointsBuilder::new("{collection_name}")
+            .filter(Filter::must([Condition::matches(
+                "color",
+                "red".to_string(),
+            )]))
+            .exact(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/typescript.md b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/typescript.md
new file mode 100644
index 000000000..6489117ac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/count-points/with-filter-exact/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+client.count("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "color",
+        match: {
+          value: "red",
+        },
+      },
+    ],
+  },
+  exact: true,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/_description.md
new file mode 100644
index 000000000..f7eddb52a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/_description.md
@@ -0,0 +1 @@
+This code sets up a collection with vectors containing 128 dimensions and a cosine distance metric. It configures the datatype for dense vectors to be Float16, which consumes less memory than Float32 without significant impact on search quality. Additionally, it specifies Float16 as the datatype for sparse text vectors in the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/csharp.md
new file mode 100644
index 000000000..c10284e87
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/csharp.md
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  vectorsConfig: new VectorParams {
+    Size = 128,
+      Distance = Distance.Cosine,
+      Datatype = Datatype.Float16
+  },
+  sparseVectorsConfig: (
+    "text",
+    new SparseVectorParams {
+      Index = new SparseIndexConfig {
+        Datatype = Datatype.Float16
+      }
+    }
+  )
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/go.md
new file mode 100644
index 000000000..d6adef29f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/go.md
@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     128,
+		Distance: qdrant.Distance_Cosine,
+		Datatype: qdrant.Datatype_Float16.Enum(),
+	}),
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"text": {
+				Index: &qdrant.SparseIndexConfig{
+					Datatype: qdrant.Datatype_Float16.Enum(),
+				},
+			},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/http.md
new file mode 100644
index 000000000..e8e7d105b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/http.md
@@ -0,0 +1,17 @@
+```http
+PUT /collections/{collection_name}
+{
+  "vectors": {
+    "size": 128,
+    "distance": "Cosine",
+    "datatype": "float16" // <-- For dense vectors
+  },
+  "sparse_vectors": {
+    "text": {
+      "index": {
+        "datatype": "float16" // <-- And for sparse vectors 
+      }
+    }
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/java.md
new file mode 100644
index 000000000..29a469b1b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/java.md
@@ -0,0 +1,35 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Datatype;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.SparseIndexConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorParams;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+  .createCollectionAsync(
+    CreateCollection.newBuilder()
+    .setCollectionName("{collection_name}")
+    .setVectorsConfig(VectorsConfig.newBuilder()
+      .setParams(VectorParams.newBuilder()
+        .setSize(128)
+        .setDistance(Distance.Cosine)
+        .setDatatype(Datatype.Float16)
+        .build())
+      .build())
+    .setSparseVectorsConfig(
+      SparseVectorConfig.newBuilder()
+      .putMap("text", SparseVectorParams.newBuilder()
+        .setIndex(SparseIndexConfig.newBuilder()
+          .setDatatype(Datatype.Float16)
+          .build())
+        .build()))
+    .build())
+  .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/python.md
new file mode 100644
index 000000000..48a0135d9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/python.md
@@ -0,0 +1,19 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(
+        size=128,
+        distance=models.Distance.COSINE,
+        datatype=models.Datatype.FLOAT16
+    ),
+    sparse_vectors_config={
+        "text": models.SparseVectorParams(
+            index=models.SparseIndexParams(datatype=models.Datatype.FLOAT16)
+        ),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/rust.md
new file mode 100644
index 000000000..ba642a7a2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/rust.md
@@ -0,0 +1,23 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Datatype, Distance, SparseIndexConfigBuilder, SparseVectorParamsBuilder, SparseVectorsConfigBuilder, VectorParamsBuilder
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
+sparse_vector_config.add_named_vector_params(
+    "text",
+    SparseVectorParamsBuilder::default()
+        .index(SparseIndexConfigBuilder::default().datatype(Datatype::Float32)),
+);
+
+let create_collection = CreateCollectionBuilder::new("{collection_name}")
+    .sparse_vectors_config(sparse_vector_config)
+    .vectors_config(
+        VectorParamsBuilder::new(128, Distance::Cosine).datatype(Datatype::Float16),
+    );
+
+client.create_collection(create_collection).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/typescript.md
new file mode 100644
index 000000000..311c3b349
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-float16-sparse-and-dense/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 128,
+    distance: "Cosine",
+    datatype: "float16"
+  },
+  sparse_vectors: {
+    text: {
+      index: {
+        datatype: "float16"
+      }
+    }
+  }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/_description.md
new file mode 100644
index 000000000..0f01f96df
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/_description.md
@@ -0,0 +1,7 @@
+When working with vectors in a collection, you can specify the datatype as Uint8 for both dense and sparse vectors. Uint8 represents integer numbers from 0 to 255, which is different from floating-point numbers. 
+
+For dense vectors, make sure the values fall within the range of 0 to 255. If the embeddings generated by your model are not in this range, you will need to quantize the values to convert them. 
+
+Some embedding providers may offer pre-quantized embeddings like Cohere int8 & binary embeddings. If not, you will have to perform quantization yourself.
+
+It's important to note that while dense vectors must be in the 0 to 255 range, sparse vectors allow for in-flight quantization. This distinction should be considered when handling Uint8 vectors.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/csharp.md
new file mode 100644
index 000000000..e4281c733
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/csharp.md
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  vectorsConfig: new VectorParams {
+    Size = 128,
+      Distance = Distance.Cosine,
+      Datatype = Datatype.Uint8
+  },
+  sparseVectorsConfig: (
+    "text",
+    new SparseVectorParams {
+      Index = new SparseIndexConfig {
+        Datatype = Datatype.Uint8
+      }
+    }
+  )
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/go.md
new file mode 100644
index 000000000..d4009f4c1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/go.md
@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     128,
+		Distance: qdrant.Distance_Cosine,
+		Datatype: qdrant.Datatype_Uint8.Enum(),
+	}),
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"text": {
+				Index: &qdrant.SparseIndexConfig{
+					Datatype: qdrant.Datatype_Uint8.Enum(),
+				},
+			},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/http.md
new file mode 100644
index 000000000..4d4ffd558
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/http.md
@@ -0,0 +1,17 @@
+```http
+PUT /collections/{collection_name}
+{
+  "vectors": {
+    "size": 128,
+    "distance": "Cosine",
+    "datatype": "uint8" // <-- For dense vectors
+  },
+  "sparse_vectors": {
+    "text": {
+      "index": {
+        "datatype": "uint8" // <-- For sparse vectors 
+      }
+    }
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/java.md
new file mode 100644
index 000000000..617358205
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/java.md
@@ -0,0 +1,35 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Datatype;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.SparseIndexConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorParams;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+  .createCollectionAsync(
+    CreateCollection.newBuilder()
+    .setCollectionName("{collection_name}")
+    .setVectorsConfig(VectorsConfig.newBuilder()
+      .setParams(VectorParams.newBuilder()
+        .setSize(128)
+        .setDistance(Distance.Cosine)
+        .setDatatype(Datatype.Uint8)
+        .build())
+      .build())
+    .setSparseVectorsConfig(
+      SparseVectorConfig.newBuilder()
+      .putMap("text", SparseVectorParams.newBuilder()
+        .setIndex(SparseIndexConfig.newBuilder()
+          .setDatatype(Datatype.Uint8)
+          .build())
+        .build()))
+    .build())
+  .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/python.md
new file mode 100644
index 000000000..bcef39551
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/python.md
@@ -0,0 +1,17 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(
+        size=128, distance=models.Distance.COSINE, datatype=models.Datatype.UINT8
+    ),
+    sparse_vectors_config={
+        "text": models.SparseVectorParams(
+            index=models.SparseIndexParams(datatype=models.Datatype.UINT8)
+        ),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/rust.md
new file mode 100644
index 000000000..9729f4893
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/rust.md
@@ -0,0 +1,26 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Datatype, Distance, SparseIndexConfigBuilder,
+    SparseVectorParamsBuilder, SparseVectorsConfigBuilder, VectorParamsBuilder,
+};
+
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
+
+sparse_vector_config.add_named_vector_params(
+    "text",
+    SparseVectorParamsBuilder::default()
+        .index(SparseIndexConfigBuilder::default().datatype(Datatype::Uint8)),
+);
+let create_collection = CreateCollectionBuilder::new("{collection_name}")
+    .sparse_vectors_config(sparse_vector_config)
+    .vectors_config(
+        VectorParamsBuilder::new(128, Distance::Cosine)
+            .datatype(Datatype::Uint8)
+    );
+
+client.create_collection(create_collection).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/typescript.md
new file mode 100644
index 000000000..8fe22c77c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8-sparse-and-dense/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 128,
+    distance: "Cosine",
+    datatype: "uint8"
+  },
+  sparse_vectors: {
+    text: {
+      index: {
+        datatype: "uint8"
+      }
+    }
+  }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/_description.md
new file mode 100644
index 000000000..acf9ac1e3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to configure Qdrant to create a collection with vectors stored as uint8 datatypes. This is useful when dealing with pre-quantized embeddings, such as uint8 embeddings provided by embedding providers like Cohere. The vectors in the collection will have a size of 1024 and will be using the Cosine distance metric for similarity comparison.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/bash.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/bash.md
new file mode 100644
index 000000000..e0316940d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/bash.md
@@ -0,0 +1,11 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+      "size": 1024,
+      "distance": "Cosine",
+      "datatype": "uint8"
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/csharp.md
new file mode 100644
index 000000000..000f82a09
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  vectorsConfig: new VectorParams {
+    Size = 1024, Distance = Distance.Cosine, Datatype = Datatype.Uint8
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/go.md
new file mode 100644
index 000000000..63b20e874
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     1024,
+		Distance: qdrant.Distance_Cosine,
+		Datatype: qdrant.Datatype_Uint8.Enum(),
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/http.md
new file mode 100644
index 000000000..3a56c73bc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 1024,
+      "distance": "Cosine",
+      "datatype": "uint8"
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/java.md
new file mode 100644
index 000000000..e9fcaafcd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/java.md
@@ -0,0 +1,18 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.grpc.Collections.Datatype;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.VectorParams;
+
+QdrantClient client = new QdrantClient(
+    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync("{collection_name}",
+        VectorParams.newBuilder()
+            .setSize(1024)
+            .setDistance(Distance.Cosine)
+            .setDatatype(Datatype.Uint8)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/python.md
new file mode 100644
index 000000000..b4530ea5b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(
+        size=1024,
+        distance=models.Distance.COSINE,
+        datatype=models.Datatype.UINT8,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/rust.md
new file mode 100644
index 000000000..c0f1d0302
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Datatype, Distance, VectorParamsBuilder,
+};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}").vectors_config(
+            VectorParamsBuilder::new(1024, Distance::Cosine).datatype(Datatype::Uint8),
+        ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/typescript.md
new file mode 100644
index 000000000..427f69b12
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/datatype-uint8/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    image: { size: 1024, distance: "Cosine", datatype: "uint8" },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/_description.md
new file mode 100644
index 000000000..3d9be5d7f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/_description.md
@@ -0,0 +1 @@
+Description: This code snippet demonstrates creating a new collection by initializing it from an existing collection. The new collection will inherit the vector settings, such as size and distance function, from the source collection specified in the `init_from` field. It is a convenient feature for testing different configurations quickly. However, caution is advised as using `init_from` may lead to unpredictable load on the cluster, especially in performance-sensitive environments. Make sure that the vectors in both collections have matching settings for size and distance function.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/bash.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/bash.md
new file mode 100644
index 000000000..ab5c9896a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/bash.md
@@ -0,0 +1,13 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+      "size": 300,
+      "distance": "Cosine"
+    },
+    "init_from": {
+       "collection": {from_collection_name}
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/csharp.md
new file mode 100644
index 000000000..f9980fa15
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 100, Distance = Distance.Cosine },
+	initFromCollection: "{from_collection_name}"
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/go.md
new file mode 100644
index 000000000..e9cff8d89
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     100,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	InitFromCollection: qdrant.PtrOf("{from_collection_name}"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/http.md
new file mode 100644
index 000000000..1a8e259e9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 100,
+      "distance": "Cosine"
+    },
+    "init_from": {
+       "collection": "{from_collection_name}"
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/java.md
new file mode 100644
index 000000000..91f030c2f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/java.md
@@ -0,0 +1,26 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(100)
+                            .setDistance(Distance.Cosine)
+                            .build()))
+            .setInitFromCollection("{from_collection_name}")
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/python.md
new file mode 100644
index 000000000..f1c485645
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=100, distance=models.Distance.COSINE),
+    init_from=models.InitFrom(collection="{from_collection_name}"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/rust.md
new file mode 100644
index 000000000..a60d2fb9b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, Distance, VectorParamsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(100, Distance::Cosine))
+            .init_from_collection("{from_collection_name}"),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/typescript.md
new file mode 100644
index 000000000..ad8c99448
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/init-from/typescript.md
@@ -0,0 +1,10 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: { size: 100, distance: "Cosine" },
+  init_from: { collection: "{from_collection_name}" },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/_description.md
new file mode 100644
index 000000000..f2080b669
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/_description.md
@@ -0,0 +1 @@
+This code defines a collection with the ability to store multiple vectors per record. Each vector, such as 'image' and 'text', has a unique name and is associated with specific distance and size parameters. The 'image' vector has a size of 4 and a distance metric of 'Dot', while the 'text' vector has a size of 8 and a distance metric of 'Cosine'. This feature enables the storage of different types of vectors within the same collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/bash.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/bash.md
new file mode 100644
index 000000000..556a4f0cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/bash.md
@@ -0,0 +1,16 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+        "image": {
+            "size": 4,
+            "distance": "Dot"
+        },
+        "text": {
+            "size": 8,
+            "distance": "Cosine"
+        }
+      }
+    }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/csharp.md
new file mode 100644
index 000000000..50453e212
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/csharp.md
@@ -0,0 +1,18 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParamsMap
+	{
+		Map =
+		{
+			["image"] = new VectorParams { Size = 4, Distance = Distance.Dot },
+			["text"] = new VectorParams { Size = 8, Distance = Distance.Cosine },
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/go.md
new file mode 100644
index 000000000..8d4d21d73
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfigMap(
+		map[string]*qdrant.VectorParams{
+			"image": {
+				Size:     4,
+				Distance: qdrant.Distance_Dot,
+			},
+			"text": {
+				Size:     8,
+				Distance: qdrant.Distance_Cosine,
+			},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/http.md
new file mode 100644
index 000000000..4af84749c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/http.md
@@ -0,0 +1,15 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+        "image": {
+            "size": 4,
+            "distance": "Dot"
+        },
+        "text": {
+            "size": 8,
+            "distance": "Cosine"
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/java.md
new file mode 100644
index 000000000..af8256393
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/java.md
@@ -0,0 +1,20 @@
+```java
+import java.util.Map;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.VectorParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        "{collection_name}",
+        Map.of(
+            "image", VectorParams.newBuilder().setSize(4).setDistance(Distance.Dot).build(),
+            "text",
+                VectorParams.newBuilder().setSize(8).setDistance(Distance.Cosine).build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/python.md
new file mode 100644
index 000000000..2d62353fa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config={
+        "image": models.VectorParams(size=4, distance=models.Distance.DOT),
+        "text": models.VectorParams(size=8, distance=models.Distance.COSINE),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/rust.md
new file mode 100644
index 000000000..d0d299e7d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, VectorParamsBuilder, VectorsConfigBuilder,
+};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut vectors_config = VectorsConfigBuilder::default();
+vectors_config
+    .add_named_vector_params("image", VectorParamsBuilder::new(4, Distance::Dot).build());
+vectors_config.add_named_vector_params(
+    "text",
+    VectorParamsBuilder::new(8, Distance::Cosine).build(),
+);
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}").vectors_config(vectors_config),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/typescript.md
new file mode 100644
index 000000000..931128336
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/multiple-vectors/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    image: { size: 4, distance: "Dot" },
+    text: { size: 8, distance: "Cosine" },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/_description.md
new file mode 100644
index 000000000..dfda058f7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/_description.md
@@ -0,0 +1 @@
+You can create a collection with named vectors in Qdrant by defining multiple vector spaces for different features or modalities like image and text. Each vector space can have a unique name along with specific size and distance calculation method. Additionally, you can include sparse vectors in the collection configuration for more efficient representation of data points.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/csharp.md
new file mode 100644
index 000000000..d8c4696d9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/csharp.md
@@ -0,0 +1,27 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  vectorsConfig: new VectorParamsMap
+  {
+      Map = {
+      ["image"] = new VectorParams {
+        Size = 4, Distance = Distance.Dot
+      },
+      ["text"] = new VectorParams {
+        Size = 5, Distance = Distance.Cosine
+      },
+    }
+  },
+  sparseVectorsConfig: new SparseVectorConfig
+  {
+      Map = {
+        ["text-sparse"] = new()
+    }
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/go.md
new file mode 100644
index 000000000..c885e58bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/go.md
@@ -0,0 +1,32 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfigMap(
+		map[string]*qdrant.VectorParams{
+			"image": {
+				Size:     4,
+				Distance: qdrant.Distance_Dot,
+			},
+			"text": {
+				Size:     5,
+				Distance: qdrant.Distance_Cosine,
+			},
+		}),
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"text-sparse": {},
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/http.md
new file mode 100644
index 000000000..b0888ead7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/http.md
@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}
+{
+  "vectors": {
+    "image": {
+      "size": 4,
+      "distance": "Dot"
+    },
+    "text": {
+      "size": 5,
+      "distance": "Cosine"
+    }
+  },
+  "sparse_vectors": {
+    "text-sparse": {}
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/java.md
new file mode 100644
index 000000000..8e5ea3bef
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/java.md
@@ -0,0 +1,36 @@
+```java
+import java.util.Map;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.SparseVectorConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorParams;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorParamsMap;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(VectorsConfig.newBuilder().setParamsMap(
+                VectorParamsMap.newBuilder().putAllMap(Map.of("image",
+                    VectorParams.newBuilder()
+                        .setSize(4)
+                        .setDistance(Distance.Dot)
+                        .build(),
+                    "text",
+                    VectorParams.newBuilder()
+                        .setSize(5)
+                        .setDistance(Distance.Cosine)
+                        .build()))))
+            .setSparseVectorsConfig(SparseVectorConfig.newBuilder().putMap(
+                "text-sparse", SparseVectorParams.getDefaultInstance()))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/python.md
new file mode 100644
index 000000000..cdab8cfae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config={
+        "image": models.VectorParams(size=4, distance=models.Distance.DOT),
+        "text": models.VectorParams(size=5, distance=models.Distance.COSINE),
+    },
+    sparse_vectors_config={"text-sparse": models.SparseVectorParams()},
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/rust.md
new file mode 100644
index 000000000..75cc8d424
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/rust.md
@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
+    VectorParamsBuilder, VectorsConfigBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut vector_config = VectorsConfigBuilder::default();
+vector_config.add_named_vector_params("text", VectorParamsBuilder::new(5, Distance::Dot));
+vector_config.add_named_vector_params("image", VectorParamsBuilder::new(4, Distance::Cosine));
+
+let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
+sparse_vectors_config
+    .add_named_vector_params("text-sparse", SparseVectorParamsBuilder::default());
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(vector_config)
+            .sparse_vectors_config(sparse_vectors_config),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/typescript.md
new file mode 100644
index 000000000..01ffe3210
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/named-vectors/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+    vectors: {
+        image: { size: 4, distance: "Dot" },
+        text: { size: 5, distance: "Cosine" },
+    },
+    sparse_vectors: {
+        text_sparse: {}
+    }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/_description.md
new file mode 100644
index 000000000..dbf57c152
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/_description.md
@@ -0,0 +1 @@
+This code snippet configures a collection where vectors are stored on disk, optimizing memory usage at the expense of search speed. It employs quantization with int8 data type and disables always keeping the data in RAM for efficient storage on fast drives like SSD or NVMe, using mmap for storage.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/csharp.md
new file mode 100644
index 000000000..80486937a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+ collectionName: "{collection_name}",
+ vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true},
+ quantizationConfig: new QuantizationConfig
+ {
+  Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = false }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/go.md
new file mode 100644
index 000000000..ef352fe0b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+		OnDisk:   qdrant.PtrOf(true),
+	}),
+	QuantizationConfig: qdrant.NewQuantizationScalar(
+		&qdrant.ScalarQuantization{
+			Type:      qdrant.QuantizationType_Int8,
+			AlwaysRam: qdrant.PtrOf(false),
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/http.md
new file mode 100644
index 000000000..042ed7b13
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/http.md
@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine",
+      "on_disk": true
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "always_ram": false
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/java.md
new file mode 100644
index 000000000..132247770
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/java.md
@@ -0,0 +1,39 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.QuantizationType;
+import io.qdrant.client.grpc.Collections.ScalarQuantization;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .setOnDisk(true)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setScalar(
+                        ScalarQuantization.newBuilder()
+                            .setType(QuantizationType.Int8)
+                            .setAlwaysRam(false)
+                            .build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/python.md
new file mode 100644
index 000000000..0b46fe650
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/python.md
@@ -0,0 +1,16 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
+    quantization_config=models.ScalarQuantization(
+        scalar=models.ScalarQuantizationConfig(
+            type=models.ScalarType.INT8,
+            always_ram=False,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/rust.md
new file mode 100644
index 000000000..084c164c7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
+            .quantization_config(
+                ScalarQuantizationBuilder::default()
+                    .r#type(QuantizationType::Int8.into())
+                    .always_ram(false),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/typescript.md
new file mode 100644
index 000000000..561560785
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/quantization-on-disk/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+    on_disk: true,
+  },
+  quantization_config: {
+    scalar: {
+      type: "int8",
+      always_ram: false,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/_description.md
new file mode 100644
index 000000000..e3582fe2d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a configuration to enable high precision and high-speed search by storing data in RAM and applying scalar quantization with an integer type of 8 bits for a specific collection. The vectors in the collection have a size of 768 and utilize cosine distance for comparison. The quantization setting ensures that the data is always stored in RAM for fast retrieval and efficient processing.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/csharp.md
new file mode 100644
index 000000000..ab2342704
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine},
+	quantizationConfig: new QuantizationConfig
+	{
+		Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = true }
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/go.md
new file mode 100644
index 000000000..05d6f4668
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	QuantizationConfig: qdrant.NewQuantizationScalar(&qdrant.ScalarQuantization{
+		Type:      qdrant.QuantizationType_Int8,
+		AlwaysRam: qdrant.PtrOf(true),
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/http.md
new file mode 100644
index 000000000..435de4d81
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/http.md
@@ -0,0 +1,15 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "always_ram": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/java.md
new file mode 100644
index 000000000..68d287de7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/java.md
@@ -0,0 +1,38 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.QuantizationType;
+import io.qdrant.client.grpc.Collections.ScalarQuantization;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setScalar(
+                        ScalarQuantization.newBuilder()
+                            .setType(QuantizationType.Int8)
+                            .setAlwaysRam(true)
+                            .build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/python.md
new file mode 100644
index 000000000..d13699ce4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/python.md
@@ -0,0 +1,16 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    quantization_config=models.ScalarQuantization(
+        scalar=models.ScalarQuantizationConfig(
+            type=models.ScalarType.INT8,
+            always_ram=True,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/rust.md
new file mode 100644
index 000000000..b7ca90097
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .quantization_config(
+                ScalarQuantizationBuilder::default()
+                    .r#type(QuantizationType::Int8.into())
+                    .always_ram(true),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/typescript.md
new file mode 100644
index 000000000..74beb3a92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-and-vectors-in-ram/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  quantization_config: {
+    scalar: {
+      type: "int8",
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/_description.md
new file mode 100644
index 000000000..2fe0bb8e7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/_description.md
@@ -0,0 +1 @@
+You can create a collection for high-speed search with low memory usage by configuring it to store original vectors on disk and quantized vectors in RAM. The quantization technique compresses vectors to `int8` using the scalar method, optimizing memory usage and minimizing disk reads for efficient search operations.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/csharp.md
new file mode 100644
index 000000000..b6ee474f2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true },
+	quantizationConfig: new QuantizationConfig
+	{
+		Scalar = new ScalarQuantization { Type = QuantizationType.Int8, AlwaysRam = true }
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/go.md
new file mode 100644
index 000000000..1dcf5be72
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+		OnDisk:   qdrant.PtrOf(true),
+	}),
+	QuantizationConfig: qdrant.NewQuantizationScalar(&qdrant.ScalarQuantization{
+		Type:      qdrant.QuantizationType_Int8,
+		AlwaysRam: qdrant.PtrOf(true),
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/http.md
new file mode 100644
index 000000000..a6db4fa63
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/http.md
@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+        "size": 768,
+        "distance": "Cosine",
+        "on_disk": true
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "always_ram": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/java.md
new file mode 100644
index 000000000..efa8019ad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/java.md
@@ -0,0 +1,39 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.QuantizationType;
+import io.qdrant.client.grpc.Collections.ScalarQuantization;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .setOnDisk(true)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setScalar(
+                        ScalarQuantization.newBuilder()
+                            .setType(QuantizationType.Int8)
+                            .setAlwaysRam(true)
+                            .build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/python.md
new file mode 100644
index 000000000..615e00a5d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/python.md
@@ -0,0 +1,16 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
+    quantization_config=models.ScalarQuantization(
+        scalar=models.ScalarQuantizationConfig(
+            type=models.ScalarType.INT8,
+            always_ram=True,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/rust.md
new file mode 100644
index 000000000..b7ca90097
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .quantization_config(
+                ScalarQuantizationBuilder::default()
+                    .r#type(QuantizationType::Int8.into())
+                    .always_ram(true),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/typescript.md
new file mode 100644
index 000000000..99df8a5a6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/scalar-quantization-in-ram/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+    on_disk: true,
+  },
+  quantization_config: {
+    scalar: {
+      type: "int8",
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/_description.md
new file mode 100644
index 000000000..8c5d60b36
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/_description.md
@@ -0,0 +1 @@
+This code snippet is used to create a collection with a specific vector configuration. The collection is defined by its name, and the vectors within the collection are set to have a size of 300 dimensions and use the Cosine distance metric.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/bash.md
new file mode 100644
index 000000000..76bd7997b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/bash.md
@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+      "size": 300,
+      "distance": "Cosine"
+    } 
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/csharp.md
new file mode 100644
index 000000000..6e0e0ed36
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 100, Distance = Distance.Cosine }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/go.md
new file mode 100644
index 000000000..e2c2d509a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     100,
+		Distance: qdrant.Distance_Cosine,
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/http.md
new file mode 100644
index 000000000..41c0797ce
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/http.md
@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 300,
+      "distance": "Cosine"
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/java.md
new file mode 100644
index 000000000..ea81e90c2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/java.md
@@ -0,0 +1,12 @@
+```java
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client = new QdrantClient(
+    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createCollectionAsync("{collection_name}",
+        VectorParams.newBuilder().setDistance(Distance.Cosine).setSize(100).build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/python.md
new file mode 100644
index 000000000..43d954e7d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/python.md
@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=100, distance=models.Distance.COSINE),
+)
+```
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/rust.md
new file mode 100644
index 000000000..dc8b4b1f7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, VectorParamsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(100, Distance::Cosine)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/typescript.md
new file mode 100644
index 000000000..5d7f84614
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/simple/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: { size: 100, distance: "Cosine" },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/_description.md
new file mode 100644
index 000000000..07a7f23ae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/_description.md
@@ -0,0 +1 @@
+Enable the IDF modifier for a specific collection to leverage the Inverse Document Frequency statistics automatically in Qdrant. By setting this modifier in the collection configuration, the search algorithm would prioritize items that occur less frequently in the collection, making them more significant in search results ranking. This feature is particularly useful for text search engines to enhance search relevance based on word rarity within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/csharp.md
new file mode 100644
index 000000000..5f3941bb4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  sparseVectorsConfig: ("text", new SparseVectorParams {
+    Modifier = Modifier.Idf,
+  })
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/go.md
new file mode 100644
index 000000000..d6e2ce4a1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"text": {
+				Modifier: qdrant.Modifier_Idf.Enum(),
+			},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/http.md
new file mode 100644
index 000000000..7008ecec7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}
+{
+    "sparse_vectors": {
+        "text": {
+            "modifier": "idf"
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/java.md
new file mode 100644
index 000000000..149626bef
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/java.md
@@ -0,0 +1,21 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Modifier;
+import io.qdrant.client.grpc.Collections.SparseVectorConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorParams;
+
+QdrantClient client =
+  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+  .createCollectionAsync(
+    CreateCollection.newBuilder()
+    .setCollectionName("{collection_name}")
+    .setSparseVectorsConfig(
+      SparseVectorConfig.newBuilder()
+      .putMap("text", SparseVectorParams.newBuilder().setModifier(Modifier.Idf).build()))
+    .build())
+  .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/python.md
new file mode 100644
index 000000000..63148d6f2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config={},
+    sparse_vectors_config={
+        "text": models.SparseVectorParams(
+            modifier=models.Modifier.IDF,
+        ),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/rust.md
new file mode 100644
index 000000000..c62eb3e6b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Modifier, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
+};
+use qdrant_client::{Qdrant, QdrantError};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
+sparse_vectors_config.add_named_vector_params(
+    "text",
+    SparseVectorParamsBuilder::default().modifier(Modifier::Idf),
+);
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .sparse_vectors_config(sparse_vectors_config),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/typescript.md
new file mode 100644
index 000000000..112e93799
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-idf/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient, Schemas } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  sparse_vectors: {
+    "text": {
+      modifier: "idf"
+    }
+  }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/_description.md
new file mode 100644
index 000000000..794cd3c1c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/_description.md
@@ -0,0 +1,3 @@
+Category: Create Collection - Sparse Vector Index on Disk
+
+This code snippet demonstrates creating a collection in Qdrant with a configuration for indexing sparse vectors. When a sparse vector index is used with the "on_disk" option set to false, it indicates that the index will be stored in memory rather than on disk. Sparse vector indexing in Qdrant is exact and does not involve approximation algorithms. The indexing method employed is similar to inverted indexes commonly found in text search engines. By specifying the configuration for sparse vectors in a collection, you can take advantage of efficient indexing optimized for vectors with a high number of zero values. This can lead to more compact and streamlined index structures, especially when managing collections that store both dense and sparse vectors.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/csharp.md
new file mode 100644
index 000000000..e7f30808d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	sparseVectorsConfig: ("splade-model-name", new SparseVectorParams{
+        Index = new SparseIndexConfig {
+            OnDisk = false,
+        }
+    })
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/go.md
new file mode 100644
index 000000000..0f3e73033
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"splade-model-name": {
+				Index: &qdrant.SparseIndexConfig{
+					OnDisk: qdrant.PtrOf(false),
+				}},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/http.md
new file mode 100644
index 000000000..a4f6d091a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}
+{
+    "sparse_vectors": {
+        "text": {
+            "index": {
+                "on_disk": false
+            }
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/java.md
new file mode 100644
index 000000000..9b11922b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/java.md
@@ -0,0 +1,27 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+import io.qdrant.client.grpc.Collections;
+
+QdrantClient client = new QdrantClient(
+    QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createCollectionAsync(
+    Collections.CreateCollection.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setSparseVectorsConfig(
+            Collections.SparseVectorConfig.newBuilder().putMap(
+                "splade-model-name",
+                Collections.SparseVectorParams.newBuilder()
+                    .setIndex(
+                        Collections.SparseIndexConfig
+                            .newBuilder()
+                            .setOnDisk(false)
+                            .build()
+                    ).build()
+            ).build()
+        ).build()
+).get();
+
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/python.md
new file mode 100644
index 000000000..b160f42ce
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config={},
+    sparse_vectors_config={
+        "text": models.SparseVectorParams(
+            index=models.SparseIndexParams(on_disk=False),
+        )
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/rust.md
new file mode 100644
index 000000000..a28b90246
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/rust.md
@@ -0,0 +1,24 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, SparseIndexConfigBuilder, SparseVectorParamsBuilder,
+    SparseVectorsConfigBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut sparse_vectors_config = SparseVectorsConfigBuilder::default();
+
+sparse_vectors_config.add_named_vector_params(
+    "splade-model-name",
+    SparseVectorParamsBuilder::default()
+        .index(SparseIndexConfigBuilder::default().on_disk(true)),
+);
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .sparse_vectors_config(sparse_vectors_config),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/typescript.md
new file mode 100644
index 000000000..350752487
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector-index-on-disk/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient, Schemas } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  sparse_vectors: {
+    "splade-model-name": {
+      index: {
+        on_disk: false
+      }
+    }
+  }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/_description.md
new file mode 100644
index 000000000..3d7eca610
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates creating a collection in Qdrant with support for sparse vectors. Sparse vectors are useful for text search, representing each word as a separate dimension. This feature allows collections to contain both sparse vectors and regular dense vectors in one point. Sparse vectors need to be named uniquely within a collection, separate from the names of dense vectors.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/bash.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/bash.md
new file mode 100644
index 000000000..7ac3bc540
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/bash.md
@@ -0,0 +1,9 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "sparse_vectors": {
+        "text": { }
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/csharp.md
new file mode 100644
index 000000000..8298e87cc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	sparseVectorsConfig: ("text", new SparseVectorParams())
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/go.md
new file mode 100644
index 000000000..bf484d171
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	SparseVectorsConfig: qdrant.NewSparseVectorsConfig(
+		map[string]*qdrant.SparseVectorParams{
+			"text": {},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/http.md
new file mode 100644
index 000000000..ca9f47b5b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/http.md
@@ -0,0 +1,8 @@
+```http
+PUT /collections/{collection_name}
+{
+    "sparse_vectors": {
+        "text": { }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/java.md
new file mode 100644
index 000000000..3e53c3730
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/java.md
@@ -0,0 +1,20 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.SparseVectorConfig;
+import io.qdrant.client.grpc.Collections.SparseVectorParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setSparseVectorsConfig(
+                SparseVectorConfig.newBuilder()
+                    .putMap("text", SparseVectorParams.getDefaultInstance()))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/python.md
new file mode 100644
index 000000000..3e44b6dc6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/python.md
@@ -0,0 +1,13 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config={},
+    sparse_vectors_config={
+        "text": models.SparseVectorParams(),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/rust.md
new file mode 100644
index 000000000..363b626a0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/rust.md
@@ -0,0 +1,19 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, SparseVectorParamsBuilder, SparseVectorsConfigBuilder,
+};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let mut sparse_vector_config = SparseVectorsConfigBuilder::default();
+
+sparse_vector_config.add_named_vector_params("text", SparseVectorParamsBuilder::default());
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .sparse_vectors_config(sparse_vector_config),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/typescript.md
new file mode 100644
index 000000000..c38533858
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/sparse-vector/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  sparse_vectors: {
+    text: { },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/_description.md
new file mode 100644
index 000000000..700b3110f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/_description.md
@@ -0,0 +1 @@
+This code configures a collection named `{collection_name}` with vectors of size 1536 and a distance metric of cosine. The collection is set up for binary quantization with the setting `always_ram` set to true. To enable binary quantization for an existing collection, a PATCH request or an `update_collection` method can be used, omitting the vector configuration as it is already defined.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/csharp.md
new file mode 100644
index 000000000..b4cce3897
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+ collectionName: "{collection_name}",
+ vectorsConfig: new VectorParams { Size = 1536, Distance = Distance.Cosine },
+ quantizationConfig: new QuantizationConfig
+ {
+  Binary = new BinaryQuantization { AlwaysRam = true }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/go.md
new file mode 100644
index 000000000..69249e594
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     1536,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	QuantizationConfig: qdrant.NewQuantizationBinary(
+		&qdrant.BinaryQuantization{
+			AlwaysRam: qdrant.PtrOf(true),
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/http.md
new file mode 100644
index 000000000..ebac542ec
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/http.md
@@ -0,0 +1,14 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 1536,
+      "distance": "Cosine"
+    },
+    "quantization_config": {
+        "binary": {
+            "always_ram": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/java.md
new file mode 100644
index 000000000..711d9a29b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/java.md
@@ -0,0 +1,32 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.BinaryQuantization;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(1536)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setBinary(BinaryQuantization.newBuilder().setAlwaysRam(true).build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/python.md
new file mode 100644
index 000000000..bf9449ca6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=1536, distance=models.Distance.COSINE),
+    quantization_config=models.BinaryQuantization(
+        binary=models.BinaryQuantizationConfig(
+            always_ram=True,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/rust.md
new file mode 100644
index 000000000..06fbe779f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{
+    BinaryQuantizationBuilder, CreateCollectionBuilder, Distance, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(1536, Distance::Cosine))
+            .quantization_config(BinaryQuantizationBuilder::new(true)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/typescript.md
new file mode 100644
index 000000000..d9889aeac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-binary-quantization/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 1536,
+    distance: "Cosine",
+  },
+  quantization_config: {
+    binary: {
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/_description.md
new file mode 100644
index 000000000..139a3ff63
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/_description.md
@@ -0,0 +1 @@
+Configure Qdrant to optimize performance by bypassing the creation of a global vector index for the entire collection. Instead, focus on indexing vectors for individual groups separately to enhance the speed of the process. Update the HNSW configuration by setting `payload_m` to a specific value, like 16, and ensuring `m` in the configuration is set to 0 to disable the global index construction.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/csharp.md
new file mode 100644
index 000000000..2fc985e3f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+	hnswConfig: new HnswConfigDiff { PayloadM = 16, M = 0 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/go.md
new file mode 100644
index 000000000..7ee6b41bc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	HnswConfig: &qdrant.HnswConfigDiff{
+		PayloadM: qdrant.PtrOf(uint64(16)),
+		M:        qdrant.PtrOf(uint64(0)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/http.md
new file mode 100644
index 000000000..cf144d856
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/http.md
@@ -0,0 +1,13 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "hnsw_config": {
+        "payload_m": 16,
+        "m": 0
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/java.md
new file mode 100644
index 000000000..94d858489
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/java.md
@@ -0,0 +1,28 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.HnswConfigDiff;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setHnswConfig(HnswConfigDiff.newBuilder().setPayloadM(16).setM(0).build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/python.md
new file mode 100644
index 000000000..4abbcdd21
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    hnsw_config=models.HnswConfigDiff(
+        payload_m=16,
+        m=0,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/rust.md
new file mode 100644
index 000000000..2a92903cf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .hnsw_config(HnswConfigDiffBuilder::default().payload_m(16).m(0)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/typescript.md
new file mode 100644
index 000000000..c056bb008
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-disabled-global-hnsw/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  hnsw_config: {
+    payload_m: 16,
+    m: 0,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/_description.md
new file mode 100644
index 000000000..217ae9df2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/_description.md
@@ -0,0 +1 @@
+By creating a collection with a high number of segments, you can optimize Qdrant to minimize latency and utilize multiple cores efficiently. Setting the segment number to match the number of cores allows for parallel processing of segments, resulting in faster query results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/csharp.md
new file mode 100644
index 000000000..fcb2c4b3f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+	optimizersConfig: new OptimizersConfigDiff { DefaultSegmentNumber = 16 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/go.md
new file mode 100644
index 000000000..1815bb198
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	OptimizersConfig: &qdrant.OptimizersConfigDiff{
+		DefaultSegmentNumber: qdrant.PtrOf(uint64(16)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/http.md
new file mode 100644
index 000000000..595674624
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "optimizers_config": {
+        "default_segment_number": 16
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/java.md
new file mode 100644
index 000000000..82d9e8793
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/java.md
@@ -0,0 +1,29 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setOptimizersConfig(
+                OptimizersConfigDiff.newBuilder().setDefaultSegmentNumber(16).build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/python.md
new file mode 100644
index 000000000..dd375c15a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    optimizers_config=models.OptimizersConfigDiff(default_segment_number=16),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/rust.md
new file mode 100644
index 000000000..fd1cd7153
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .optimizers_config(
+                OptimizersConfigDiffBuilder::default().default_segment_number(16),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/typescript.md
new file mode 100644
index 000000000..7ad31275f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-high-number-of-segments/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  optimizers_config: {
+    default_segment_number: 16,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/_description.md
new file mode 100644
index 000000000..9bb0af63a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/_description.md
@@ -0,0 +1 @@
+This code snippet creates a collection with specific configurations for vectors and optimizers. It sets the vector size to 768 and the distance metric to Cosine. It also configures the optimizers with a default segment number of 2 and a maximum segment size of 5000000. These settings aim to optimize throughput by utilizing fewer segments to handle parallel requests and benefit from large segment sizes for optimized index performance.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/csharp.md
new file mode 100644
index 000000000..031ed69e2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+	optimizersConfig: new OptimizersConfigDiff { DefaultSegmentNumber = 2, MaxSegmentSize = 5000000 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/go.md
new file mode 100644
index 000000000..dd1fc60ce
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	OptimizersConfig: &qdrant.OptimizersConfigDiff{
+		DefaultSegmentNumber: qdrant.PtrOf(uint64(2)),
+		MaxSegmentSize:       qdrant.PtrOf(uint64(5000000)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/http.md
new file mode 100644
index 000000000..a765cc1d1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/http.md
@@ -0,0 +1,13 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "optimizers_config": {
+        "default_segment_number": 2,
+        "max_segment_size": 5000000
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/java.md
new file mode 100644
index 000000000..5be80e6c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/java.md
@@ -0,0 +1,33 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setOptimizersConfig(
+                OptimizersConfigDiff.newBuilder()
+                    .setDefaultSegmentNumber(2)
+                    .setMaxSegmentSize(5000000)
+                    .build()
+            )
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/python.md
new file mode 100644
index 000000000..3c89f87f0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    optimizers_config=models.OptimizersConfigDiff(default_segment_number=2, max_segment_size=5000000),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/rust.md
new file mode 100644
index 000000000..1cd9f8cbf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .optimizers_config(
+                OptimizersConfigDiffBuilder::default().default_segment_number(2).max_segment_size(5000000),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/typescript.md
new file mode 100644
index 000000000..5cb9ed1ef
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-large-segments/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  optimizers_config: {
+    default_segment_number: 2,
+    max_segment_size: 5000000,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/_description.md
new file mode 100644
index 000000000..ecd97c895
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/_description.md
@@ -0,0 +1 @@
+To utilize multivectors in Qdrant, you can create a collection with a specified configuration. This configuration includes defining the size of the vectors (128 in this case), setting the distance metric as cosine, and enabling the multivector feature with the comparator function as `max_sim`. The `max_sim` function calculates the similarity between matrices of vectors by summing the maximum similarities between each pair of vectors in the matrices. This allows for scenarios where you may have multiple representations of the same object or late interaction embeddings, such as text embedding models outputting multiple vectors for a single text sequence.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/csharp.md
new file mode 100644
index 000000000..286597cfe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/csharp.md
@@ -0,0 +1,17 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  vectorsConfig: new VectorParams {
+    Size = 128,
+      Distance = Distance.Cosine,
+      MultivectorConfig = new() {
+        Comparator = MultiVectorComparator.MaxSim
+      }
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/go.md
new file mode 100644
index 000000000..c6017cf40
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     128,
+		Distance: qdrant.Distance_Cosine,
+		MultivectorConfig: &qdrant.MultiVectorConfig{
+			Comparator: qdrant.MultiVectorComparator_MaxSim,
+		},
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/http.md
new file mode 100644
index 000000000..b2083a964
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/http.md
@@ -0,0 +1,12 @@
+```http
+PUT collections/{collection_name}
+{
+  "vectors": {
+    "size": 128,
+    "distance": "Cosine",
+    "multivector_config": {
+      "comparator": "max_sim"
+    }
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/java.md
new file mode 100644
index 000000000..c31c472d2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/java.md
@@ -0,0 +1,19 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.MultiVectorComparator;
+import io.qdrant.client.grpc.Collections.MultiVectorConfig;
+import io.qdrant.client.grpc.Collections.VectorParams;
+
+QdrantClient client =
+  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createCollectionAsync("{collection_name}",
+  VectorParams.newBuilder().setSize(128)
+  .setDistance(Distance.Cosine)
+  .setMultivectorConfig(MultiVectorConfig.newBuilder()
+    .setComparator(MultiVectorComparator.MaxSim)
+    .build())
+  .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/python.md
new file mode 100644
index 000000000..7ce3c5d52
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/python.md
@@ -0,0 +1,17 @@
+```python
+
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(
+        size=128,
+        distance=models.Distance.COSINE,
+        multivector_config=models.MultiVectorConfig(
+            comparator=models.MultiVectorComparator.MAX_SIM
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/rust.md
new file mode 100644
index 000000000..59e9df878
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, VectorParamsBuilder,
+    MultiVectorComparator, MultiVectorConfigBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(
+                VectorParamsBuilder::new(100, Distance::Cosine)
+                    .multivector_config(
+                        MultiVectorConfigBuilder::new(MultiVectorComparator::MaxSim)
+                    ),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/typescript.md
new file mode 100644
index 000000000..59349e343
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-multivector/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 128,
+    distance: "Cosine",
+    multivector_config: {
+      comparator: "max_sim"
+    }
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/_description.md
new file mode 100644
index 000000000..be94c9cc3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/_description.md
@@ -0,0 +1 @@
+Creates a collection with vectors stored in memmap storage and specifies an optimizer configuration with a `memmap_threshold` set to 20000. This configuration is particularly useful for Qdrant instances with fast disks and large collections. The `memmap_threshold` option determines the threshold after which a segment will be converted to memmap storage. It can be set globally in the configuration file or for each collection individually during creation or update.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/csharp.md
new file mode 100644
index 000000000..a55b19420
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+	optimizersConfig: new OptimizersConfigDiff { MemmapThreshold = 20000 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/go.md
new file mode 100644
index 000000000..98a8cd1ae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	OptimizersConfig: &qdrant.OptimizersConfigDiff{
+		MaxSegmentSize: qdrant.PtrOf(uint64(20000)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/http.md
new file mode 100644
index 000000000..377b2202b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "optimizers_config": {
+        "memmap_threshold": 20000
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/java.md
new file mode 100644
index 000000000..321b15ce8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/java.md
@@ -0,0 +1,29 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setOptimizersConfig(
+                OptimizersConfigDiff.newBuilder().setMemmapThreshold(20000).build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/python.md
new file mode 100644
index 000000000..d52521575
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    optimizers_config=models.OptimizersConfigDiff(memmap_threshold=20000),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/rust.md
new file mode 100644
index 000000000..43bd4f1d7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, OptimizersConfigDiffBuilder, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .optimizers_config(OptimizersConfigDiffBuilder::default().memmap_threshold(20000)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/typescript.md
new file mode 100644
index 000000000..7155f67f6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-optimizer-config/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  optimizers_config: {
+    memmap_threshold: 20000,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/_description.md
new file mode 100644
index 000000000..35e096f18
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/_description.md
@@ -0,0 +1 @@
+This code snippet is configuring a collection with product quantization. It defines the vector size and distance metric for vectors in the collection, and specifies parameters for product quantization such as compression and storage settings. It highlights the process of setting up product quantization and mentions the specific details to include in the configuration. It also suggests using a PATCH request or the corresponding method for updating an existing collection without modifying the vector configuration.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/csharp.md
new file mode 100644
index 000000000..7fbdaea03
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+ collectionName: "{collection_name}",
+ vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+ quantizationConfig: new QuantizationConfig
+ {
+  Product = new ProductQuantization { Compression = CompressionRatio.X16, AlwaysRam = true }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/go.md
new file mode 100644
index 000000000..44482a3f4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	QuantizationConfig: qdrant.NewQuantizationProduct(
+		&qdrant.ProductQuantization{
+			Compression: qdrant.CompressionRatio_x16,
+			AlwaysRam:   qdrant.PtrOf(true),
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/http.md
new file mode 100644
index 000000000..8eef5bbd9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/http.md
@@ -0,0 +1,15 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "quantization_config": {
+        "product": {
+            "compression": "x16",
+            "always_ram": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/java.md
new file mode 100644
index 000000000..9f56ccacf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/java.md
@@ -0,0 +1,37 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CompressionRatio;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.ProductQuantization;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setProduct(
+                        ProductQuantization.newBuilder()
+                            .setCompression(CompressionRatio.x16)
+                            .setAlwaysRam(true)
+                            .build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/python.md
new file mode 100644
index 000000000..709b8e281
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/python.md
@@ -0,0 +1,16 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    quantization_config=models.ProductQuantization(
+        product=models.ProductQuantizationConfig(
+            compression=models.CompressionRatio.X16,
+            always_ram=True,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/rust.md
new file mode 100644
index 000000000..514fd004d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/rust.md
@@ -0,0 +1,19 @@
+```rust
+use qdrant_client::qdrant::{
+    CompressionRatio, CreateCollectionBuilder, Distance, ProductQuantizationBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .quantization_config(
+                ProductQuantizationBuilder::new(CompressionRatio::X16.into()).always_ram(true),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/typescript.md
new file mode 100644
index 000000000..a7abe3b14
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-product-quantization/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  quantization_config: {
+    product: {
+      compression: "x16",
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/_description.md
new file mode 100644
index 000000000..bec06680f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the configuration to create a collection with scalar quantization parameters. The `quantization_config` section includes specifications for scalar quantization, such as the data type (`int8`), the quantile value (0.99), and whether it should always be in RAM. To enable scalar quantization for an existing collection, you can use a PATCH request or the `update_collection` method, excluding the vector configuration that's already defined.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/csharp.md
new file mode 100644
index 000000000..43ea3c3cd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/csharp.md
@@ -0,0 +1,20 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+ collectionName: "{collection_name}",
+ vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine },
+ quantizationConfig: new QuantizationConfig
+ {
+  Scalar = new ScalarQuantization
+  {
+   Type = QuantizationType.Int8,
+   Quantile = 0.99f,
+   AlwaysRam = true
+  }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/go.md
new file mode 100644
index 000000000..f7098ba92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+	}),
+	QuantizationConfig: qdrant.NewQuantizationScalar(
+		&qdrant.ScalarQuantization{
+            Type:      qdrant.QuantizationType_Int8,
+			Quantile:  qdrant.PtrOf(float32(0.99)),
+			AlwaysRam: qdrant.PtrOf(true),
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/http.md
new file mode 100644
index 000000000..78f841a52
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/http.md
@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine"
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "quantile": 0.99,
+            "always_ram": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/java.md
new file mode 100644
index 000000000..441d6c40d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/java.md
@@ -0,0 +1,38 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.QuantizationConfig;
+import io.qdrant.client.grpc.Collections.QuantizationType;
+import io.qdrant.client.grpc.Collections.ScalarQuantization;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .build())
+                    .build())
+            .setQuantizationConfig(
+                QuantizationConfig.newBuilder()
+                    .setScalar(
+                        ScalarQuantization.newBuilder()
+                            .setType(QuantizationType.Int8)
+                            .setQuantile(0.99f)
+                            .setAlwaysRam(true)
+                            .build())
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/python.md
new file mode 100644
index 000000000..7eac2c717
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/python.md
@@ -0,0 +1,17 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE),
+    quantization_config=models.ScalarQuantization(
+        scalar=models.ScalarQuantizationConfig(
+            type=models.ScalarType.INT8,
+            quantile=0.99,
+            always_ram=True,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/rust.md
new file mode 100644
index 000000000..ba7f9ea49
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, QuantizationType, ScalarQuantizationBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine))
+            .quantization_config(
+                ScalarQuantizationBuilder::default()
+                    .r#type(QuantizationType::Int8.into())
+                    .quantile(0.99)
+                    .always_ram(true),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/typescript.md
new file mode 100644
index 000000000..ad5c65690
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-scalar-quantization-params/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+  },
+  quantization_config: {
+    scalar: {
+      type: "int8",
+      quantile: 0.99,
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/_description.md
new file mode 100644
index 000000000..9d839a5ee
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/_description.md
@@ -0,0 +1 @@
+When creating a collection with vectors and HNSW index stored on disk, it is recommended to set the `memmap_threshold` parameter based on your use case. For a balanced scenario, keep it equal to the `indexing_threshold` (default is 20000) to optimize all thresholds at once. If facing high write load and low RAM, set `memmap_threshold` lower than `indexing_threshold`, for example 10000, to prioritize converting segments to memmap storage before indexing. Remember, you can store both vectors and the HNSW index on disk by setting `hnsw_config.on_disk` to `true` during collection creation or updating.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/csharp.md
new file mode 100644
index 000000000..3ec75dc15
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	vectorsConfig: new VectorParams { Size = 768, Distance = Distance.Cosine, OnDisk = true },
+	hnswConfig: new HnswConfigDiff { OnDisk = true }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/go.md
new file mode 100644
index 000000000..ccb465068
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+		OnDisk:   qdrant.PtrOf(true),
+	}),
+	HnswConfig: &qdrant.HnswConfigDiff{
+		OnDisk: qdrant.PtrOf(true),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/http.md
new file mode 100644
index 000000000..c8c084a81
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/http.md
@@ -0,0 +1,13 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine",
+      "on_disk": true
+    },
+    "hnsw_config": {
+        "on_disk": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/java.md
new file mode 100644
index 000000000..bf071ec63
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/java.md
@@ -0,0 +1,29 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.HnswConfigDiff;
+import io.qdrant.client.grpc.Collections.VectorParams;
+import io.qdrant.client.grpc.Collections.VectorsConfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setVectorsConfig(
+                VectorsConfig.newBuilder()
+                    .setParams(
+                        VectorParams.newBuilder()
+                            .setSize(768)
+                            .setDistance(Distance.Cosine)
+                            .setOnDisk(true)
+                            .build())
+                    .build())
+            .setHnswConfig(HnswConfigDiff.newBuilder().setOnDisk(true).build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/python.md
new file mode 100644
index 000000000..58303eb29
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(size=768, distance=models.Distance.COSINE, on_disk=True),
+    hnsw_config=models.HnswConfigDiff(on_disk=True),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/rust.md
new file mode 100644
index 000000000..f1b9615e1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, HnswConfigDiffBuilder,
+    VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true))
+            .hnsw_config(HnswConfigDiffBuilder::default().on_disk(true)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/typescript.md
new file mode 100644
index 000000000..4d5b251ff
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-and-hnsw-on-disk/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+    on_disk: true,
+  },
+  hnsw_config: {
+    on_disk: true,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/_description.md
new file mode 100644
index 000000000..1634ea9ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to configure Memmap storage, also known as on-disk storage, for a collection. You can achieve this by setting the `on_disk` option to true in the vectors configuration within the collection creation API. This feature is available starting from version 1.2.0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/csharp.md
new file mode 100644
index 000000000..fe7bed084
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	"{collection_name}",
+	new VectorParams
+	{
+		Size = 768,
+		Distance = Distance.Cosine,
+		OnDisk = true
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/go.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/go.md
new file mode 100644
index 000000000..32e1beda9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfig(&qdrant.VectorParams{
+		Size:     768,
+		Distance: qdrant.Distance_Cosine,
+		OnDisk:   qdrant.PtrOf(true),
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/http.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/http.md
new file mode 100644
index 000000000..159a0c233
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}
+{
+    "vectors": {
+      "size": 768,
+      "distance": "Cosine",
+      "on_disk": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/java.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/java.md
new file mode 100644
index 000000000..d4cac287b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/java.md
@@ -0,0 +1,19 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.Distance;
+import io.qdrant.client.grpc.Collections.VectorParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        "{collection_name}",
+        VectorParams.newBuilder()
+            .setSize(768)
+            .setDistance(Distance.Cosine)
+            .setOnDisk(true)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/python.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/python.md
new file mode 100644
index 000000000..b896b067c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/python.md
@@ -0,0 +1,12 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    vectors_config=models.VectorParams(
+        size=768, distance=models.Distance.COSINE, on_disk=True
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/rust.md
new file mode 100644
index 000000000..094009f12
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{CreateCollectionBuilder, Distance, VectorParamsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(768, Distance::Cosine).on_disk(true)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/typescript.md
new file mode 100644
index 000000000..4b4cb063e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-collection/with-vectors-on-disk/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  vectors: {
+    size: 768,
+    distance: "Cosine",
+    on_disk: true,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/_description.md
new file mode 100644
index 000000000..9dba2cdd5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to create a payload index for a timestamp field with an integer type. The "is_principal" property is set to true, indicating that this field will be used as the principal index for faster search performance. This feature is particularly useful for optimizing storage and speeding up search requests, especially when filtering data primarily based on the principal field, such as a timestamp in time-related data scenarios.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/csharp.md
new file mode 100644
index 000000000..a20d41832
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+ collectionName: "{collection_name}",
+ fieldName: "timestamp",
+ schemaType: PayloadSchemaType.Integer,
+ indexParams: new PayloadIndexParams
+ {
+  IntegerIndexParams = new IntegerIndexParams
+  {
+   IsPrincipal = true
+  }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/go.md
new file mode 100644
index 000000000..fe0fb3cc9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "name_of_the_field_to_index",
+	FieldType:      qdrant.FieldType_FieldTypeInteger.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParamsInt(
+		&qdrant.IntegerIndexParams{
+			IsPrincipal: qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/http.md
new file mode 100644
index 000000000..75369f379
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "timestamp",
+    "field_schema": {
+        "type": "integer",
+        "is_principal": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/java.md
new file mode 100644
index 000000000..fa2d251d7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/java.md
@@ -0,0 +1,26 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+import io.qdrant.client.grpc.Collections.IntegerIndexParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "timestamp",
+        PayloadSchemaType.Integer,
+        PayloadIndexParams.newBuilder()
+            .setIntegerIndexParams(
+                KeywordIndexParams.newBuilder()
+                    .setIsPrincipa(true)
+                    .build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/python.md
new file mode 100644
index 000000000..69df16ef1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/python.md
@@ -0,0 +1,10 @@
+```python
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="timestamp",
+    field_schema=models.IntegerIndexParams(
+        type=models.IntegerIndexType.INTEGER,
+        is_principal=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/rust.md
new file mode 100644
index 000000000..8e3f282e3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateFieldIndexCollectionBuilder,
+    IntegerIndexParamsBuilder,
+    FieldType
+};
+use qdrant_client::{Qdrant, QdrantError};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_field_index(
+    CreateFieldIndexCollectionBuilder::new(
+        "{collection_name}",
+        "timestamp",
+        FieldType::Integer,
+    )
+    .field_index_params(
+        IntegerIndexParamsBuilder::default()
+            .is_principal(true),
+    ),
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/typescript.md
new file mode 100644
index 000000000..a508ab8cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-is-principal/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.createPayloadIndex("{collection_name}", {
+  field_name: "timestamp",
+  field_schema: {
+    type: "integer",
+    is_principal: true
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/_description.md
new file mode 100644
index 000000000..8d1821481
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to create an index for an integer field within a collection. The index can be fine-tuned for improved performance by specifying whether direct lookup and range filters are enabled. In this case, a parameterized variant of the integer index is set up to support only range filters, which can be beneficial for collections with a large number of data points. It is recommended to experiment with the parameterized index to optimize performance, and if needed, revert back to the regular integer index. Be cautious when setting up both direct lookup and range filters, as it may impact performance negatively.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/csharp.md
new file mode 100644
index 000000000..6fb7c3c7b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/csharp.md
@@ -0,0 +1,20 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+    collectionName: "{collection_name}",
+    fieldName: "name_of_the_field_to_index",
+    schemaType: PayloadSchemaType.Integer,
+    indexParams: new PayloadIndexParams
+    {
+	    IntegerIndexParams = new()
+	    {
+		    Lookup = false,
+		    Range = true
+	    }
+    }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/go.md
new file mode 100644
index 000000000..3c3c87762
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "name_of_the_field_to_index",
+	FieldType:      qdrant.FieldType_FieldTypeInteger.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParamsInt(
+		&qdrant.IntegerIndexParams{
+			Lookup: false,
+			Range:  true,
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/http.md
new file mode 100644
index 000000000..b7b5444e4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/http.md
@@ -0,0 +1,11 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "name_of_the_field_to_index",
+    "field_schema": {
+        "type": "integer",
+        "lookup": false,
+        "range": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/java.md
new file mode 100644
index 000000000..473dc3aac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/java.md
@@ -0,0 +1,24 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.IntegerIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "name_of_the_field_to_index",
+        PayloadSchemaType.Integer,
+        PayloadIndexParams.newBuilder()
+            .setIntegerIndexParams(
+                IntegerIndexParams.newBuilder().setLookup(false).setRange(true).build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/python.md
new file mode 100644
index 000000000..57065aad9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="name_of_the_field_to_index",
+    field_schema=models.IntegerIndexParams(
+        type=models.IntegerIndexType.INTEGER,
+        lookup=False,
+        range=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/rust.md
new file mode 100644
index 000000000..c26a39eae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/rust.md
@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::qdrant::{
+    payload_index_params::IndexParams, CreateFieldIndexCollectionBuilder, FieldType,
+    IntegerIndexParams, PayloadIndexParams,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_field_index(
+        CreateFieldIndexCollectionBuilder::new(
+            "{collection_name}",
+            "name_of_the_field_to_index",
+            FieldType::Integer,
+        )
+        .field_index_params(PayloadIndexParams {
+            index_params: Some(IndexParams::IntegerIndexParams(IntegerIndexParams {
+                lookup: false,
+                range: true,
+            })),
+        }),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/typescript.md
new file mode 100644
index 000000000..3b53fcd2e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/integer-with-params/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createPayloadIndex("{collection_name}", {
+  field_name: "name_of_the_field_to_index",
+  field_schema: {
+    type: "integer",
+    lookup: false,
+    range: true,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/_description.md
new file mode 100644
index 000000000..a760f783c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/_description.md
@@ -0,0 +1 @@
+Creates a payload index for a specific collection where the field is defined as a keyword type and marked as tenant-specific. This configuration allows Qdrant to optimize storage and retrieval by structuring the data based on the specified field for improved search efficiency of tenant-specific data subsets within the collection. This feature is particularly beneficial in multi-tenant environments where data subsets belong to different tenants, enabling more targeted and faster searches within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/csharp.md
new file mode 100644
index 000000000..c87e2bd51
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+ collectionName: "{collection_name}",
+ fieldName: "payload_field_name",
+ schemaType: PayloadSchemaType.Keyword,
+ indexParams: new PayloadIndexParams
+ {
+  KeywordIndexParams = new KeywordIndexParams
+  {
+   IsTenant = true
+  }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/go.md
new file mode 100644
index 000000000..c3dd40bb1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "name_of_the_field_to_index",
+	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParamsKeyword(
+		&qdrant.KeywordIndexParams{
+			IsTenant: qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/http.md
new file mode 100644
index 000000000..2c90d3219
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "payload_field_name",
+    "field_schema": {
+        "type": "keyword",
+        "is_tenant": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/java.md
new file mode 100644
index 000000000..63b2b9508
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/java.md
@@ -0,0 +1,26 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+import io.qdrant.client.grpc.Collections.KeywordIndexParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "payload_field_name",
+        PayloadSchemaType.Keyword,
+        PayloadIndexParams.newBuilder()
+            .setKeywordIndexParams(
+                KeywordIndexParams.newBuilder()
+                    .setIsTenant(true)
+                    .build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/python.md
new file mode 100644
index 000000000..143a64b5a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/python.md
@@ -0,0 +1,10 @@
+```python
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="payload_field_name",
+    field_schema=models.KeywordIndexParams(
+        type=models.KeywordIndexType.KEYWORD,
+        is_tenant=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/rust.md
new file mode 100644
index 000000000..3cd242de6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateFieldIndexCollectionBuilder,
+    KeywordIndexParamsBuilder,
+    FieldType
+};
+use qdrant_client::{Qdrant, QdrantError};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_field_index(
+    CreateFieldIndexCollectionBuilder::new(
+        "{collection_name}",
+        "payload_field_name",
+        FieldType::Keyword,
+    )
+    .field_index_params(
+        KeywordIndexParamsBuilder::default()
+            .is_tenant(true),
+    ),
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/typescript.md
new file mode 100644
index 000000000..772668236
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-is-tenant/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.createPayloadIndex("{collection_name}", {
+  field_name: "payload_field_name",
+  field_schema: {
+    type: "keyword",
+    is_tenant: true
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/_description.md
new file mode 100644
index 000000000..30ae017e5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/_description.md
@@ -0,0 +1 @@
+Creates a payload index for a specified collection and field name with a keyword type that is stored on disk. Storing the payload index on disk allows for efficient access to payload values during search, especially for cases where the payload indexes are large or rarely used. However, it's important to note that storing payload indexes on disk may impact the latency of cold requests due to additional disk I/O operations.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/csharp.md
new file mode 100644
index 000000000..bb8ff80d2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+ collectionName: "{collection_name}",
+ fieldName: "payload_field_name",
+ schemaType: PayloadSchemaType.Keyword,
+ indexParams: new PayloadIndexParams
+ {
+  KeywordIndexParams = new KeywordIndexParams
+  {
+   OnDisk   = true
+  }
+ }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/go.md
new file mode 100644
index 000000000..c4f155ad6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "name_of_the_field_to_index",
+	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParamsKeyword(
+		&qdrant.KeywordIndexParams{
+			OnDisk: qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/http.md
new file mode 100644
index 000000000..85e1ba51a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "payload_field_name",
+    "field_schema": {
+        "type": "keyword",
+        "on_disk": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/java.md
new file mode 100644
index 000000000..b9cb9ea1d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/java.md
@@ -0,0 +1,26 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+import io.qdrant.client.grpc.Collections.KeywordIndexParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "payload_field_name",
+        PayloadSchemaType.Keyword,
+        PayloadIndexParams.newBuilder()
+            .setKeywordIndexParams(
+                KeywordIndexParams.newBuilder()
+                    .setOnDisk(true)
+                    .build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/python.md
new file mode 100644
index 000000000..14c6ed829
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/python.md
@@ -0,0 +1,10 @@
+```python
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="payload_field_name",
+    field_schema=models.KeywordIndexParams(
+        type=models.KeywordIndexType.KEYWORD,
+        on_disk=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/rust.md
new file mode 100644
index 000000000..77f231a4b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateFieldIndexCollectionBuilder,
+    KeywordIndexParamsBuilder,
+    FieldType
+};
+use qdrant_client::{Qdrant, QdrantError};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_field_index(
+    CreateFieldIndexCollectionBuilder::new(
+        "{collection_name}",
+        "payload_field_name",
+        FieldType::Keyword,
+    )
+    .field_index_params(
+        KeywordIndexParamsBuilder::default()
+            .on_disk(true),
+    ),
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/typescript.md
new file mode 100644
index 000000000..4b992ab06
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/keyword-on-disk/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.createPayloadIndex("{collection_name}", {
+  field_name: "payload_field_name",
+  field_schema: {
+    type: "keyword",
+    on_disk: true
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/_description.md
new file mode 100644
index 000000000..9a7ba6df5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to create a full-text index for a specified field in a collection. The index configuration includes details such as the field name, type (text), tokenizer (word), minimum and maximum token length, and whether to convert tokens to lowercase. This setup enables filtering points based on the presence of specific words or phrases in the field, allowing for efficient full-text search functionality within the payload.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/csharp.md
new file mode 100644
index 000000000..0da1ac700
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/csharp.md
@@ -0,0 +1,22 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+	collectionName: "{collection_name}",
+	fieldName: "name_of_the_field_to_index",
+	schemaType: PayloadSchemaType.Text,
+	indexParams: new PayloadIndexParams
+	{
+		TextIndexParams = new TextIndexParams
+		{
+			Tokenizer = TokenizerType.Word,
+			MinTokenLen = 2,
+			MaxTokenLen = 10,
+			Lowercase = true
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/go.md
new file mode 100644
index 000000000..3fca77a39
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "name_of_the_field_to_index",
+	FieldType:      qdrant.FieldType_FieldTypeText.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParamsText(
+		&qdrant.TextIndexParams{
+			Tokenizer:   qdrant.TokenizerType_Whitespace,
+			MinTokenLen: qdrant.PtrOf(uint64(2)),
+			MaxTokenLen: qdrant.PtrOf(uint64(10)),
+			Lowercase:   qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/http.md
new file mode 100644
index 000000000..3af0ed3d9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/http.md
@@ -0,0 +1,13 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "name_of_the_field_to_index",
+    "field_schema": {
+        "type": "text",
+        "tokenizer": "word",
+        "min_token_len": 2,
+        "max_token_len": 20,
+        "lowercase": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/java.md
new file mode 100644
index 000000000..0d2b435ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/java.md
@@ -0,0 +1,30 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+import io.qdrant.client.grpc.Collections.TextIndexParams;
+import io.qdrant.client.grpc.Collections.TokenizerType;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "name_of_the_field_to_index",
+        PayloadSchemaType.Text,
+        PayloadIndexParams.newBuilder()
+            .setTextIndexParams(
+                TextIndexParams.newBuilder()
+                    .setTokenizer(TokenizerType.Word)
+                    .setMinTokenLen(2)
+                    .setMaxTokenLen(10)
+                    .setLowercase(true)
+                    .build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/python.md
new file mode 100644
index 000000000..360fe6a9d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/python.md
@@ -0,0 +1,17 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="name_of_the_field_to_index",
+    field_schema=models.TextIndexParams(
+        type="text",
+        tokenizer=models.TokenizerType.WORD,
+        min_token_len=2,
+        max_token_len=15,
+        lowercase=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/rust.md
new file mode 100644
index 000000000..a1a5244dd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/rust.md
@@ -0,0 +1,27 @@
+```rust
+use qdrant_client::qdrant::{
+    payload_index_params::IndexParams, CreateFieldIndexCollectionBuilder, FieldType,
+    PayloadIndexParams, TextIndexParams, TokenizerType,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_field_index(
+        CreateFieldIndexCollectionBuilder::new(
+            "{collection_name}",
+            "name_of_the_field_to_index",
+            FieldType::Text,
+        )
+        .field_index_params(PayloadIndexParams {
+            index_params: Some(IndexParams::TextIndexParams(TextIndexParams {
+                tokenizer: TokenizerType::Word as i32,
+                min_token_len: Some(2),
+                max_token_len: Some(10),
+                lowercase: Some(true),
+            })),
+        }),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/typescript.md
new file mode 100644
index 000000000..87a69d43d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-full-text/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createPayloadIndex("{collection_name}", {
+  field_name: "name_of_the_field_to_index",
+  field_schema: {
+    type: "text",
+    tokenizer: "word",
+    min_token_len: 2,
+    max_token_len: 15,
+    lowercase: true,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/_description.md
new file mode 100644
index 000000000..cab81e695
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/_description.md
@@ -0,0 +1 @@
+Create a payload index by specifying the field name and setting its schema to 'keyword'. This allows for more efficient searching with filters in Qdrant. Indexing fields can impact the vector index as well. It is recommended to index fields that might heavily influence search results. For example, indexing the object ID, which is unique for each record, will be more efficient than indexing by color with only a few possible values. Qdrant will prioritize using the most restrictive index in compound queries involving multiple fields.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/csharp.md
new file mode 100644
index 000000000..f689341ac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/csharp.md
@@ -0,0 +1,10 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+    collectionName: "{collection_name}",
+    fieldName: "name_of_the_field_to_index"
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/go.md
new file mode 100644
index 000000000..82b399b71
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/go.md
@@ -0,0 +1,18 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+    CollectionName: "{collection_name}",
+    FieldName:      "name_of_the_field_to_index",
+    FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/http.md
new file mode 100644
index 000000000..ea8fba4de
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/http.md
@@ -0,0 +1,7 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "name_of_the_field_to_index",
+    "field_schema": "keyword"
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/java.md
new file mode 100644
index 000000000..17c8738ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/java.md
@@ -0,0 +1,12 @@
+```java
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+
+client.createPayloadIndexAsync(
+    "{collection_name}",
+    "name_of_the_field_to_index",
+    PayloadSchemaType.Keyword,
+    null,
+    true,
+    null,
+    null);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/python.md
new file mode 100644
index 000000000..984fc9b79
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/python.md
@@ -0,0 +1,7 @@
+```python
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="name_of_the_field_to_index",
+    field_schema="keyword",
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/rust.md
new file mode 100644
index 000000000..468cb325b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::qdrant::{CreateFieldIndexCollectionBuilder, FieldType};
+
+client
+    .create_field_index(
+        CreateFieldIndexCollectionBuilder::new(
+            "{collection_name}",
+            "name_of_the_field_to_index",
+            FieldType::Keyword,
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/typescript.md
new file mode 100644
index 000000000..ccb454446
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/simple-keyword/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+client.createPayloadIndex("{collection_name}", {
+  field_name: "name_of_the_field_to_index",
+  field_schema: "keyword",
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/_description.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/_description.md
new file mode 100644
index 000000000..2fc583af5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/_description.md
@@ -0,0 +1 @@
+Generate a keyword payload index for the `group_id` field with the option to mark it as a tenant using the `is_tenant` parameter, starting from version 1.11.0. If using versions prior to that, default settings for keyword index creation should be utilized.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/csharp.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/csharp.md
new file mode 100644
index 000000000..50dbb7296
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/csharp.md
@@ -0,0 +1,18 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreatePayloadIndexAsync(
+	collectionName: "{collection_name}",
+	fieldName: "group_id",
+	schemaType: PayloadSchemaType.Keyword,
+	indexParams: new PayloadIndexParams
+	{
+		KeywordIndexParams = new KeywordIndexParams
+		{
+			IsTenant = true
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/go.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/go.md
new file mode 100644
index 000000000..72f14d66c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFieldIndex(context.Background(), &qdrant.CreateFieldIndexCollection{
+	CollectionName: "{collection_name}",
+	FieldName:      "group_id",
+	FieldType:      qdrant.FieldType_FieldTypeKeyword.Enum(),
+	FieldIndexParams: qdrant.NewPayloadIndexParams(
+		&qdrant.KeywordIndexParams{
+			IsTenant: qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/http.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/http.md
new file mode 100644
index 000000000..2641c13e8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/http.md
@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}/index
+{
+    "field_name": "group_id",
+    "field_schema": {
+        "type": "keyword",
+        "is_tenant": true
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/java.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/java.md
new file mode 100644
index 000000000..0b5395d1b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/java.md
@@ -0,0 +1,26 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.PayloadIndexParams;
+import io.qdrant.client.grpc.Collections.PayloadSchemaType;
+import io.qdrant.client.grpc.Collections.KeywordIndexParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createPayloadIndexAsync(
+        "{collection_name}",
+        "group_id",
+        PayloadSchemaType.Keyword,
+        PayloadIndexParams.newBuilder()
+            .setKeywordIndexParams(
+                KeywordIndexParams.newBuilder()
+                    .setIsTenant(true)
+                    .build())
+            .build(),
+        null,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/python.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/python.md
new file mode 100644
index 000000000..302f13e68
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/python.md
@@ -0,0 +1,10 @@
+```python
+client.create_payload_index(
+    collection_name="{collection_name}",
+    field_name="group_id",
+    field_schema=models.KeywordIndexParams(
+        type="keyword",
+        is_tenant=True,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/rust.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/rust.md
new file mode 100644
index 000000000..fca664ef0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateFieldIndexCollectionBuilder,
+    KeywordIndexParamsBuilder,
+    FieldType
+};
+use qdrant_client::{Qdrant, QdrantError};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_field_index(
+        CreateFieldIndexCollectionBuilder::new(
+            "{collection_name}",
+            "group_id",
+            FieldType::Keyword,
+        ).field_index_params(
+            KeywordIndexParamsBuilder::default()
+                .is_tenant(true)
+        )
+    ).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/typescript.md b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/typescript.md
new file mode 100644
index 000000000..b0661bdfd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/create-payload-index/with-group-id-as-tenant/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.createPayloadIndex("{collection_name}", {
+  field_name: "group_id",
+  field_schema: {
+    type: "keyword",
+    is_tenant: true,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/_description.md
new file mode 100644
index 000000000..55326cf6e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/_description.md
@@ -0,0 +1 @@
+This code snippet is for deleting a collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/bash.md
new file mode 100644
index 000000000..89ce7a1af
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X DELETE http://localhost:6333/collections/{collection_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/csharp.md
new file mode 100644
index 000000000..72bf6c8ab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.DeleteCollectionAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/go.md
new file mode 100644
index 000000000..cee9c6d2d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/go.md
@@ -0,0 +1,5 @@
+```go
+import "context"
+
+client.DeleteCollection(context.Background(), "{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/http.md
new file mode 100644
index 000000000..0be233150
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/http.md
@@ -0,0 +1,3 @@
+```http
+DELETE http://localhost:6333/collections/{collection_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/java.md
new file mode 100644
index 000000000..35587e1b2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/java.md
@@ -0,0 +1,3 @@
+```java
+client.deleteCollectionAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/python.md
new file mode 100644
index 000000000..799116d19
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/python.md
@@ -0,0 +1,3 @@
+```python
+client.delete_collection(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/rust.md
new file mode 100644
index 000000000..cbb66bab3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/rust.md
@@ -0,0 +1,3 @@
+```rust
+client.delete_collection("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/typescript.md
new file mode 100644
index 000000000..d142972b5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-collection/simple/typescript.md
@@ -0,0 +1,3 @@
+```typescript
+client.deleteCollection("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/_description.md
new file mode 100644
index 000000000..db9529588
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/_description.md
@@ -0,0 +1 @@
+This code snippet shows an example of using filters to delete specific keys from a payload based on defined criteria. In this example, it showcases how to delete keys "color" and "price" where the "color" key matches the value "red".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/csharp.md
new file mode 100644
index 000000000..213234888
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeletePayloadAsync(
+    collectionName: "{collection_name}",
+    keys: ["color", "price"],
+    filter: MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/go.md
new file mode 100644
index 000000000..9dc4b7bd2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.DeletePayload(context.Background(), &qdrant.DeletePayloadPoints{
+    CollectionName: "{collection_name}",
+    Keys:           []string{"color", "price"},
+    PointsSelector: qdrant.NewPointsSelectorFilter(
+        &qdrant.Filter{
+            Must: []*qdrant.Condition{qdrant.NewMatch("color", "red")},
+        },
+    ),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/http.md
new file mode 100644
index 000000000..75ea438ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/http.md
@@ -0,0 +1,16 @@
+```http
+POST /collections/{collection_name}/points/payload/delete
+{
+    "keys": ["color", "price"],
+    "filter": {
+        "must": [
+            {
+                "key": "color",
+                "match": {
+                    "value": "red"
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/java.md
new file mode 100644
index 000000000..2122c52e4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/java.md
@@ -0,0 +1,15 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+client
+    .deletePayloadAsync(
+        "{collection_name}",
+        List.of("color", "price"),
+        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
+        true,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/python.md
new file mode 100644
index 000000000..2c50f9410
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/python.md
@@ -0,0 +1,14 @@
+```python
+client.delete_payload(
+    collection_name="{collection_name}",
+    keys=["color", "price"],
+    points=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="color",
+                match=models.MatchValue(value="red"),
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/rust.md
new file mode 100644
index 000000000..e2382260b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{Condition, DeletePayloadPointsBuilder, Filter};
+
+client
+    .delete_payload(
+        DeletePayloadPointsBuilder::new(
+            "{collection_name}",
+            vec!["color".to_string(), "price".to_string()],
+        )
+        .points_selector(Filter::must([Condition::matches(
+            "color",
+            "red".to_string(),
+        )]))
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/typescript.md
new file mode 100644
index 000000000..490cb6ddc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-filter/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+client.deletePayload("{collection_name}", {
+  keys: ["color", "price"],
+  filter: {
+    must: [
+      {
+        key: "color",
+        match: {
+          value: "red",
+        },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/_description.md
new file mode 100644
index 000000000..5920a190c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/_description.md
@@ -0,0 +1 @@
+This code snippet pertains to deleting specific keys from the payload of points. It specifies the keys to be deleted as 'color' and 'price' from the points with IDs 0, 3, and 100 within a collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/csharp.md
new file mode 100644
index 000000000..90775fb6d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeletePayloadAsync(
+    collectionName: "{collection_name}",
+    keys: ["color", "price"],
+    ids: new ulong[] { 0, 3, 100 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/go.md
new file mode 100644
index 000000000..509165bed
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.DeletePayload(context.Background(), &qdrant.DeletePayloadPoints{
+    CollectionName: "{collection_name}",
+    Keys:           []string{"color", "price"},
+    PointsSelector: qdrant.NewPointsSelector(
+        qdrant.NewIDNum(0),
+        qdrant.NewIDNum(3)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/http.md
new file mode 100644
index 000000000..6ec056c45
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/http.md
@@ -0,0 +1,7 @@
+```http
+POST /collections/{collection_name}/points/payload/delete
+{
+    "keys": ["color", "price"],
+    "points": [0, 3, 100]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/java.md
new file mode 100644
index 000000000..f4ceb0378
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/java.md
@@ -0,0 +1,15 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+
+client
+    .deletePayloadAsync(
+        "{collection_name}",
+        List.of("color", "price"),
+        List.of(id(0), id(3), id(100)),
+        true,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/python.md
new file mode 100644
index 000000000..c2b9817fd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/python.md
@@ -0,0 +1,7 @@
+```python
+client.delete_payload(
+    collection_name="{collection_name}",
+    keys=["color", "price"],
+    points=[0, 3, 100],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/rust.md
new file mode 100644
index 000000000..e1fecee6a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{DeletePayloadPointsBuilder, PointsIdsList};
+
+client
+    .delete_payload(
+        DeletePayloadPointsBuilder::new(
+            "{collection_name}",
+            vec!["color".to_string(), "price".to_string()],
+        )
+        .points_selector(PointsIdsList {
+            ids: vec![0.into(), 3.into(), 10.into()],
+        })
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/typescript.md
new file mode 100644
index 000000000..bb6f1bd30
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-payload/by-point-id/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+client.deletePayload("{collection_name}", {
+  keys: ["color", "price"],
+  points: [0, 3, 100],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/_description.md
new file mode 100644
index 000000000..988229d69
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates an alternative way to specify and remove certain points from a collection by filtering based on a specific key-value pair. In this case, the filter is set to remove points with the key "color" that match the value "red".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/csharp.md
new file mode 100644
index 000000000..bfde0c26a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/csharp.md
@@ -0,0 +1,8 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeleteAsync(collectionName: "{collection_name}", filter: MatchKeyword("color", "red"));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/go.md
new file mode 100644
index 000000000..23a5d1b10
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Delete(context.Background(), &qdrant.DeletePoints{
+	CollectionName: "{collection_name}",
+	Points: qdrant.NewPointsSelectorFilter(
+		&qdrant.Filter{
+			Must: []*qdrant.Condition{
+				qdrant.NewMatch("color", "red"),
+			},
+		},
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/http.md
new file mode 100644
index 000000000..af7d6c35b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/http.md
@@ -0,0 +1,15 @@
+```http
+POST /collections/{collection_name}/points/delete
+{
+    "filter": {
+        "must": [
+            {
+                "key": "color",
+                "match": {
+                    "value": "red"
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/java.md
new file mode 100644
index 000000000..78f5595fd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/java.md
@@ -0,0 +1,11 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+
+client
+    .deleteAsync(
+        "{collection_name}",
+        Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/python.md
new file mode 100644
index 000000000..a3992e3a4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/python.md
@@ -0,0 +1,15 @@
+```python
+client.delete(
+    collection_name="{collection_name}",
+    points_selector=models.FilterSelector(
+        filter=models.Filter(
+            must=[
+                models.FieldCondition(
+                    key="color",
+                    match=models.MatchValue(value="red"),
+                ),
+            ],
+        )
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/rust.md
new file mode 100644
index 000000000..cd801822f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::qdrant::{Condition, DeletePointsBuilder, Filter};
+
+client
+    .delete_points(
+        DeletePointsBuilder::new("{collection_name}")
+            .points(Filter::must([Condition::matches(
+                "color",
+                "red".to_string(),
+            )]))
+            .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/typescript.md
new file mode 100644
index 000000000..19f9833a6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/by-filter/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+client.delete("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "color",
+        match: {
+          value: "red",
+        },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/_description.md
new file mode 100644
index 000000000..a12c98f06
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/_description.md
@@ -0,0 +1 @@
+This code represents a task to delete specific points from a collection. The API endpoint allows you to send a POST request to delete points with the specified indexes (0, 3, and 100) from a collection specified by its name.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/csharp.md
new file mode 100644
index 000000000..7e7e22087
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeleteAsync(collectionName: "{collection_name}", ids: [0, 3, 100]);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/go.md
new file mode 100644
index 000000000..0c0c628bb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Delete(context.Background(), &qdrant.DeletePoints{
+	CollectionName: "{collection_name}",
+	Points: qdrant.NewPointsSelector(
+		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(100),
+	),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/http.md
new file mode 100644
index 000000000..7b67e16b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/http.md
@@ -0,0 +1,6 @@
+```http
+POST /collections/{collection_name}/points/delete
+{
+    "points": [0, 3, 100]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/java.md
new file mode 100644
index 000000000..ac0b869b8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/java.md
@@ -0,0 +1,7 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+
+client.deleteAsync("{collection_name}", List.of(id(0), id(3), id(100)));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/python.md
new file mode 100644
index 000000000..75b7cc45c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/python.md
@@ -0,0 +1,8 @@
+```python
+client.delete(
+    collection_name="{collection_name}",
+    points_selector=models.PointIdsList(
+        points=[0, 3, 100],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/rust.md
new file mode 100644
index 000000000..eba218bfd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{DeletePointsBuilder, PointsIdsList};
+
+client
+    .delete_points(
+        DeletePointsBuilder::new("{collection_name}")
+            .points(PointsIdsList {
+                ids: vec![0.into(), 3.into(), 100.into()],
+            })
+            .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/typescript.md
new file mode 100644
index 000000000..b77404d7e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-points/simple/typescript.md
@@ -0,0 +1,5 @@
+```typescript
+client.delete("{collection_name}", {
+  points: [0, 3, 100],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/_description.md
new file mode 100644
index 000000000..b0012b176
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a way to delete specific vectors from specified points in a collection. It allows users to remove selected vectors while retaining other vectors associated with the points. The points themselves are not deleted during this process, only certain vectors are removed. This method is available starting from version 1.2.0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/csharp.md
new file mode 100644
index 000000000..2307284f9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.DeleteVectorsAsync("{collection_name}", ["text", "image"], [0, 3, 10]);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/go.md
new file mode 100644
index 000000000..58d05dab1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/go.md
@@ -0,0 +1,16 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client.DeleteVectors(context.Background(), &qdrant.DeletePointVectors{
+	CollectionName: "{collection_name}",
+	PointsSelector: qdrant.NewPointsSelector(
+		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(10)),
+	Vectors: &qdrant.VectorsSelector{
+		Names: []string{"text", "image"},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/http.md
new file mode 100644
index 000000000..9a87c397d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/http.md
@@ -0,0 +1,7 @@
+```http
+POST /collections/{collection_name}/points/vectors/delete
+{
+    "points": [0, 3, 100],
+    "vectors": ["text", "image"]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/java.md
new file mode 100644
index 000000000..bab855fee
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/java.md
@@ -0,0 +1,10 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+
+client
+    .deleteVectorsAsync(
+        "{collection_name}", List.of("text", "image"), List.of(id(0), id(3), id(10)))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/python.md
new file mode 100644
index 000000000..573cbd762
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/python.md
@@ -0,0 +1,7 @@
+```python
+client.delete_vectors(
+    collection_name="{collection_name}",
+    points=[0, 3, 100],
+    vectors=["text", "image"],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/rust.md
new file mode 100644
index 000000000..d9a64db2a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{
+    DeletePointVectorsBuilder, PointsIdsList,
+};
+
+client
+    .delete_vectors(
+        DeletePointVectorsBuilder::new("{collection_name}")
+            .points_selector(PointsIdsList {
+                ids: vec![0.into(), 3.into(), 10.into()],
+            })
+            .vectors(vec!["text".into(), "image".into()])
+            .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/typescript.md
new file mode 100644
index 000000000..4c7a0fa86
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/delete-vectors/simple/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+client.deleteVectors("{collection_name}", {
+  points: [0, 3, 10],
+  vector: ["text", "image"],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/_description.md
new file mode 100644
index 000000000..1b6c53339
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/_description.md
@@ -0,0 +1 @@
+This code snippet represents a request to retrieve a distance matrix in pairwise format for points in a collection. The matrix will contain pairs of point IDs along with their corresponding scores based on a specific filtering condition (in this case, filtering by the color red). The request aims to return a limited number of samples that meet the filter criteria.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/csharp.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/csharp.md
new file mode 100644
index 000000000..7c87fb44b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/csharp.md
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.SearchMatrixPairsAsync(
+    collectionName: "{collection_name}",
+    filter: MatchKeyword("color", "red"),
+    sample: 10,
+    limit: 2
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/go.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/go.md
new file mode 100644
index 000000000..3bc56b523
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+sample := uint64(10)
+limit := uint64(2)
+res, err := client.SearchMatrixPairs(ctx, &qdrant.SearchMatrixPoints{
+    CollectionName: "{collection_name}",
+    Sample:         &sample,
+    Limit:          &limit,
+    Filter: &qdrant.Filter{
+        Must: []*qdrant.Condition{
+            qdrant.NewMatch("color", "red"),
+        },
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/http.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/http.md
new file mode 100644
index 000000000..487c00c28
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/search/matrix/pairs
+{
+    "sample": 10,
+    "limit": 2,
+    "filter": {
+        "must": {
+            "key": "color",
+            "match": { "value": "red" }
+        }
+    }  
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/java.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/java.md
new file mode 100644
index 000000000..4ec4cdb76
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/java.md
@@ -0,0 +1,21 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.SearchMatrixPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .searchMatrixPairsAsync(
+        Points.SearchMatrixPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+            .setSample(10)
+            .setLimit(2)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/python.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/python.md
new file mode 100644
index 000000000..ba8350b1c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/python.md
@@ -0,0 +1,18 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.search_matrix_pairs(
+    collection_name="{collection_name}",
+    sample=10,
+    limit=2,
+    query_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="color", match=models.MatchValue(value="red")
+            ),
+        ]
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/rust.md
new file mode 100644
index 000000000..6e11c6350
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, SearchMatrixPointsBuilder};
+use qdrant_client::Qdrant;
+
+client
+    .search_matrix_pairs(
+        SearchMatrixPointsBuilder::new("collection_name")
+           .filter(Filter::must(vec![Condition::matches(
+               "color",
+               "red".to_string(),
+           )]))
+           .sample(10)
+           .limit(2),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/typescript.md
new file mode 100644
index 000000000..8e7d466ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/basic/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.searchMatrixPairs("{collection_name}", {
+    filter: {
+        must: [
+            {
+                key: "color",
+                match: {
+                    value: "red",
+                },
+            },
+        ],
+    },
+    sample: 10,
+    limit: 2,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/_description.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/_description.md
new file mode 100644
index 000000000..b1989a3f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/_description.md
@@ -0,0 +1 @@
+This code snippet describes how to obtain a distance matrix in an offsets format. The distance matrix is represented through four arrays: `offsets_row` and `offsets_col` indicate the positions of non-zero distance values in the matrix, `scores` holds the distance values, and `ids` stores the point ids associated with the distance values.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/csharp.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/csharp.md
new file mode 100644
index 000000000..45d611b3c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/csharp.md
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.SearchMatrixOffsetsAsync(
+    collectionName: "{collection_name}",
+    filter: MatchKeyword("color", "red"),
+    sample: 10,
+    limit: 2
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/go.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/go.md
new file mode 100644
index 000000000..391d00e9e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+sample := uint64(10)
+limit := uint64(2)
+res, err := client.SearchMatrixOffsets(ctx, &qdrant.SearchMatrixPoints{
+    CollectionName: "{collection_name}",
+    Sample:         &sample,
+    Limit:          &limit,
+    Filter: &qdrant.Filter{
+        Must: []*qdrant.Condition{
+            qdrant.NewMatch("color", "red"),
+        },
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/http.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/http.md
new file mode 100644
index 000000000..36ee6116e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/search/matrix/offsets
+{
+    "sample": 10,
+    "limit": 2,
+    "filter": {
+        "must": {
+            "key": "color",
+            "match": { "value": "red" }
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/java.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/java.md
new file mode 100644
index 000000000..a48491e6f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/java.md
@@ -0,0 +1,21 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.SearchMatrixPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .searchMatrixOffsetsAsync(
+        SearchMatrixPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+            .setSample(10)
+            .setLimit(2)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/python.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/python.md
new file mode 100644
index 000000000..b65970a6b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/python.md
@@ -0,0 +1,18 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.search_matrix_offsets(
+    collection_name="{collection_name}",
+    sample=10,
+    limit=2,
+    query_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="color", match=models.MatchValue(value="red")
+            ),
+        ]
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/rust.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/rust.md
new file mode 100644
index 000000000..f8dd89fbe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, SearchMatrixPointsBuilder};
+use qdrant_client::Qdrant;
+
+client
+    .search_matrix_offsets(
+        SearchMatrixPointsBuilder::new("collection_name")
+           .filter(Filter::must(vec![Condition::matches(
+               "color",
+               "red".to_string(),
+           )]))
+           .sample(10)
+           .limit(2),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/typescript.md b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/typescript.md
new file mode 100644
index 000000000..717956791
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/distance-matrix/offsets-format/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.searchMatrixOffsets("{collection_name}", {
+    filter: {
+        must: [
+            {
+                key: "color",
+                match: {
+                    value: "red",
+                },
+            },
+        ],
+    },
+    sample: 10,
+    limit: 2,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/_description.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/_description.md
new file mode 100644
index 000000000..7e6447626
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/_description.md
@@ -0,0 +1 @@
+This code snippet is a request to retrieve facet counts for a specific key within a collection. The response will contain values sorted by count in descending order and then by value in ascending order. It specifies that only values with non-zero counts will be included in the results. By setting the `exact` parameter to `true`, it ensures that the counts returned are precise instead of approximate, which is useful for debugging storage or when an exact count is needed.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/csharp.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/csharp.md
new file mode 100644
index 000000000..f17043f9e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/csharp.md
@@ -0,0 +1,9 @@
+```csharp
+using Qdrant.Client;
+
+await client.FacetAsync(
+    "{collection_name}",
+    key: "size",
+    exact: true,
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/go.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/go.md
new file mode 100644
index 000000000..0fe5d8ae0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/go.md
@@ -0,0 +1,7 @@
+```go
+res, err := client.Facet(ctx, &qdrant.FacetCounts{
+    CollectionName: "{collection_name}",
+    Key:            "key",
+    Exact:          true,
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/http.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/http.md
new file mode 100644
index 000000000..fa96c2572
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/http.md
@@ -0,0 +1,7 @@
+```http
+POST /collections/{collection_name}/facet
+{
+    "key": "size",
+    "exact": true
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/java.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/java.md
new file mode 100644
index 000000000..50f9661cd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/java.md
@@ -0,0 +1,10 @@
+```java
+ client
+      .facetAsync(
+          Points.FacetCounts.newBuilder()
+              .setCollectionName(collection_name)
+              .setKey("foo")
+              .setExact(true)
+              .build())
+      .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/python.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/python.md
new file mode 100644
index 000000000..eafa8e676
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/python.md
@@ -0,0 +1,7 @@
+```python
+client.facet(
+    collection_name="{collection_name}",
+    key="size",
+    exact=True,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/rust.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/rust.md
new file mode 100644
index 000000000..a397a4a3f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::FacetCountsBuilder;
+
+client
+    .facet(
+         FacetCountsBuilder::new("{collection_name}", "size")
+             .limit(10)
+             .exact(true),
+     )
+     .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/typescript.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/typescript.md
new file mode 100644
index 000000000..982f71dad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/exact/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+client.facet("{collection_name}", {
+    key: "size",
+    exact: true,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/_description.md
new file mode 100644
index 000000000..ff5e05e42
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/_description.md
@@ -0,0 +1 @@
+Faceting is a feature that allows you to retrieve counts of unique values for a specific field within your data. In this case, the snippet demonstrates a request to generate facet counts for a field named "size" in a collection. The facet counts are filtered based on a condition where the "color" must match the value "red". This technique can help you understand the distribution of values in your data and assess the impact of applying filters based on specific values.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/csharp.md
new file mode 100644
index 000000000..3fb46ce43
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.FacetAsync(
+    "{collection_name}",
+    key: "size",
+    filter: MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/go.md
new file mode 100644
index 000000000..6af8804b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+res, err := client.Facet(ctx, &qdrant.FacetCounts{
+    CollectionName: "{collection_name}",
+    Key:            "size",
+        Filter: &qdrant.Filter{
+        Must: []*qdrant.Condition{
+            qdrant.NewMatch("color", "red"),
+        },
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/http.md
new file mode 100644
index 000000000..1659ad531
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/facet
+{
+    "key": "size",
+    "filter": {
+      "must": {
+        "key": "color",
+        "match": { "value": "red" }
+      }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/java.md
new file mode 100644
index 000000000..c47a0d988
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/java.md
@@ -0,0 +1,20 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import io.qdrant.client.grpc.Points;
+import io.qdrant.client.grpc.Filter;
+
+QdrantClient client = new QdrantClient(
+                QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .facetAsync(
+        Points.FacetCounts.newBuilder()
+            .setCollectionName(collection_name)
+            .setKey("size")
+            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+            .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/python.md
new file mode 100644
index 000000000..cab97f497
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.facet(
+    collection_name="{collection_name}",
+    key="size",
+    facet_filter=models.Filter(must=[models.Match("color", "red")]),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/rust.md
new file mode 100644
index 000000000..80e7616ed
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{Condition, FacetCountsBuilder, Filter};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .facet(
+         FacetCountsBuilder::new("{collection_name}", "size")
+             .limit(10)
+             .filter(Filter::must(vec![Condition::matches(
+                 "color",
+                 "red".to_string(),
+             )])),
+     )
+     .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/typescript.md
new file mode 100644
index 000000000..5cb14a2b7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/facet-counts/simple-with-filter/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.facet("{collection_name}", {
+    filter: {
+        must: [
+            {
+                key: "color",
+                match: {
+                    value: "red",
+                },
+            },
+        ],
+    },
+    key: "size",
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/_description.md
new file mode 100644
index 000000000..32b83cdb7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/_description.md
@@ -0,0 +1 @@
+This code snippet represents a filter condition based on date range for a specific field. The condition specifies that the date should be greater than "2023-02-08T10:49:00Z" and less than or equal to "2024-01-31T10:14:31Z". The comparison for dates is done based on the RFC 3339 format, and no conversion to UNIX timestamps is required. The dates are parsed and compared in UTC format.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/csharp.md
new file mode 100644
index 000000000..35ff21fdb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/csharp.md
@@ -0,0 +1,9 @@
+```csharp
+using Qdrant.Client.Grpc;
+
+Conditions.DatetimeRange(
+    field: "date",
+    gt: new DateTime(2023, 2, 8, 10, 49, 0, DateTimeKind.Utc),
+    lte: new DateTime(2024, 1, 31, 10, 14, 31, DateTimeKind.Utc)
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/go.md
new file mode 100644
index 000000000..8325e3a8f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/go.md
@@ -0,0 +1,13 @@
+```go
+import (
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+qdrant.NewDatetimeRange("date", &qdrant.DatetimeRange{
+	Gt:  timestamppb.New(time.Date(2023, 2, 8, 10, 49, 0, 0, time.UTC)),
+	Lte: timestamppb.New(time.Date(2024, 1, 31, 10, 14, 31, 0, time.UTC)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/java.md
new file mode 100644
index 000000000..cea9fde24
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/java.md
@@ -0,0 +1,16 @@
+```java
+import static io.qdrant.client.ConditionFactory.datetimeRange;
+
+import com.google.protobuf.Timestamp;
+import io.qdrant.client.grpc.Points.DatetimeRange;
+import java.time.Instant;
+
+long gt = Instant.parse("2023-02-08T10:49:00Z").getEpochSecond();
+long lte = Instant.parse("2024-01-31T10:14:31Z").getEpochSecond();
+
+datetimeRange("date",
+    DatetimeRange.newBuilder()
+        .setGt(Timestamp.newBuilder().setSeconds(gt))
+        .setLte(Timestamp.newBuilder().setSeconds(lte))
+        .build());
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/json.md
new file mode 100644
index 000000000..0fa38cb98
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/json.md
@@ -0,0 +1,11 @@
+```json
+{
+  "key": "date",
+  "range": {
+    "gt": "2023-02-08T10:49:00Z",
+    "gte": null,
+    "lt": null,
+    "lte": "2024-01-31 10:14:31Z"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/python.md
new file mode 100644
index 000000000..85649e666
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/python.md
@@ -0,0 +1,11 @@
+```python
+models.FieldCondition(
+    key="date",
+    range=models.DatetimeRange(
+        gt="2023-02-08T10:49:00Z",
+        gte=None,
+        lt=None,
+        lte="2024-01-31T10:14:31Z",
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/rust.md
new file mode 100644
index 000000000..9fe4f3c0f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{Condition, DatetimeRange, Timestamp};
+
+Condition::datetime_range(
+    "date",
+    DatetimeRange {
+        gt: Some(Timestamp::date_time(2023, 2, 8, 10, 49, 0).unwrap()),
+        gte: None,
+        lt: None,
+        lte: Some(Timestamp::date_time(2024, 1, 31, 10, 14, 31).unwrap()),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/typescript.md
new file mode 100644
index 000000000..40abe392e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/datetime-range/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+{
+    key: 'date',
+    range: {
+        gt: '2023-02-08T10:49:00Z',
+        gte: null,
+        lt: null,
+        lte: '2024-01-31T10:14:31Z'
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/_description.md
new file mode 100644
index 000000000..8ee9241dc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/_description.md
@@ -0,0 +1 @@
+This code snippet sets up a field condition to search for a specific substring or phrase within a text field. In this case, a special `text` match is defined with the target text being "good cheap". The behavior may vary depending on the configuration of the full-text index for the field. If there is no full-text index configured for the field, the condition will work as an exact substring match.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/csharp.md
new file mode 100644
index 000000000..ab6e2ef2a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+MatchText("description", "good cheap");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/go.md
new file mode 100644
index 000000000..dfd93a99e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatchText("description", "good cheap")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/java.md
new file mode 100644
index 000000000..c4d4006d0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchText;
+
+matchText("description", "good cheap");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/json.md
new file mode 100644
index 000000000..538080ff8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "description",
+  "match": {
+    "text": "good cheap"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/python.md
new file mode 100644
index 000000000..f2a61979d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="description",
+    match=models.MatchText(text="good cheap"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/rust.md
new file mode 100644
index 000000000..5cedb5b94
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/rust.md
@@ -0,0 +1,5 @@
+```rust
+use qdrant_client::qdrant::Condition;
+
+Condition::matches_text("description", "good cheap")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/typescript.md
new file mode 100644
index 000000000..a4df05df0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/full-text-match/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'description',
+    match: {text: 'good cheap'}    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/_description.md
new file mode 100644
index 000000000..54e4a920c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/_description.md
@@ -0,0 +1 @@
+This code defines a filter condition based on a geo bounding box for a location field. The bounding box is specified by its top-left and bottom-right coordinates on a map.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/csharp.md
new file mode 100644
index 000000000..5fe83e8f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+GeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/go.md
new file mode 100644
index 000000000..f1d321170
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewGeoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/java.md
new file mode 100644
index 000000000..ce5f9a916
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.geoBoundingBox;
+
+geoBoundingBox("location", 52.520711, 13.403683, 52.495862, 13.455868);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/json.md
new file mode 100644
index 000000000..071617267
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/json.md
@@ -0,0 +1,15 @@
+```json
+{
+  "key": "location",
+  "geo_bounding_box": {
+    "bottom_right": {
+      "lon": 13.455868,
+      "lat": 52.495862
+    },
+    "top_left": {
+      "lon": 13.403683,
+      "lat": 52.520711
+    }
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/python.md
new file mode 100644
index 000000000..428022bf5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/python.md
@@ -0,0 +1,15 @@
+```python
+models.FieldCondition(
+    key="location",
+    geo_bounding_box=models.GeoBoundingBox(
+        bottom_right=models.GeoPoint(
+            lon=13.455868,
+            lat=52.495862,
+        ),
+        top_left=models.GeoPoint(
+            lon=13.403683,
+            lat=52.520711,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/rust.md
new file mode 100644
index 000000000..95da0cfd1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{Condition, GeoBoundingBox, GeoPoint};
+
+Condition::geo_bounding_box(
+    "location",
+    GeoBoundingBox {
+        bottom_right: Some(GeoPoint {
+            lon: 13.455868,
+            lat: 52.495862,
+        }),
+        top_left: Some(GeoPoint {
+            lon: 13.403683,
+            lat: 52.520711,
+        }),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/typescript.md
new file mode 100644
index 000000000..26aa7497e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-bounding-box/typescript.md
@@ -0,0 +1,15 @@
+```typescript
+{
+    key: 'location',
+    geo_bounding_box: {
+        bottom_right: {
+            lon: 13.455868,
+            lat: 52.495862
+        },
+        top_left: {
+            lon: 13.403683,
+            lat: 52.520711
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/_description.md
new file mode 100644
index 000000000..7c6efdd21
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/_description.md
@@ -0,0 +1 @@
+This code snippet represents a geo polygon filter condition for location data. It defines an irregularly shaped area with an exterior boundary and an optional interior boundary. The exterior boundary is specified with a sequence of points, while the interior boundary is also defined with a separate sequence of points. The code uses longitude and latitude coordinates to create the geo polygon, offering a way to filter points based on their location within the specified polygon.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/csharp.md
new file mode 100644
index 000000000..e02911026
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/csharp.md
@@ -0,0 +1,32 @@
+```csharp
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+GeoPolygon(
+	field: "location",
+	exterior: new GeoLineString
+	{
+		Points =
+		{
+			new GeoPoint { Lat = -70.0, Lon = -70.0 },
+			new GeoPoint { Lat = 60.0, Lon = -70.0 },
+			new GeoPoint { Lat = 60.0, Lon = 60.0 },
+			new GeoPoint { Lat = -70.0, Lon = 60.0 },
+			new GeoPoint { Lat = -70.0, Lon = -70.0 }
+		}
+	},
+	interiors: [
+		new()
+		{
+			Points =
+			{
+				new GeoPoint { Lat = -65.0, Lon = -65.0 },
+				new GeoPoint { Lat = 0.0, Lon = -65.0 },
+				new GeoPoint { Lat = 0.0, Lon = 0.0 },
+				new GeoPoint { Lat = -65.0, Lon = 0.0 },
+				new GeoPoint { Lat = -65.0, Lon = -65.0 }
+			}
+		}
+	]
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/go.md
new file mode 100644
index 000000000..af4dacedc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/go.md
@@ -0,0 +1,22 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewGeoPolygon("location",
+	&qdrant.GeoLineString{
+		Points: []*qdrant.GeoPoint{
+			{Lat: -70, Lon: -70},
+			{Lat: 60, Lon: -70},
+			{Lat: 60, Lon: 60},
+			{Lat: -70, Lon: 60},
+			{Lat: -70, Lon: -70},
+		},
+	}, &qdrant.GeoLineString{
+		Points: []*qdrant.GeoPoint{
+			{Lat: -65, Lon: -65},
+			{Lat: 0, Lon: -65},
+			{Lat: 0, Lon: 0},
+			{Lat: -65, Lon: 0},
+			{Lat: -65, Lon: -65},
+		},
+	})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/java.md
new file mode 100644
index 000000000..37ed261bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/java.md
@@ -0,0 +1,28 @@
+```java
+import static io.qdrant.client.ConditionFactory.geoPolygon;
+
+import io.qdrant.client.grpc.Points.GeoLineString;
+import io.qdrant.client.grpc.Points.GeoPoint;
+
+geoPolygon(
+    "location",
+    GeoLineString.newBuilder()
+        .addAllPoints(
+            List.of(
+                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build(),
+                GeoPoint.newBuilder().setLon(60.0).setLat(-70.0).build(),
+                GeoPoint.newBuilder().setLon(60.0).setLat(60.0).build(),
+                GeoPoint.newBuilder().setLon(-70.0).setLat(60.0).build(),
+                GeoPoint.newBuilder().setLon(-70.0).setLat(-70.0).build()))
+        .build(),
+    List.of(
+        GeoLineString.newBuilder()
+            .addAllPoints(
+                List.of(
+                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build(),
+                    GeoPoint.newBuilder().setLon(0.0).setLat(-65.0).build(),
+                    GeoPoint.newBuilder().setLon(0.0).setLat(0.0).build(),
+                    GeoPoint.newBuilder().setLon(-65.0).setLat(0.0).build(),
+                    GeoPoint.newBuilder().setLon(-65.0).setLat(-65.0).build()))
+            .build()));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/json.md
new file mode 100644
index 000000000..039252abe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/json.md
@@ -0,0 +1,28 @@
+```json
+
+{
+  "key": "location",
+  "geo_polygon": {
+    "exterior": {
+      "points": [
+        { "lon": -70.0, "lat": -70.0 },
+        { "lon": 60.0, "lat": -70.0 },
+        { "lon": 60.0, "lat": 60.0 },
+        { "lon": -70.0, "lat": 60.0 },
+        { "lon": -70.0, "lat": -70.0 }
+      ]
+    },
+    "interiors": [
+      {
+        "points": [
+          { "lon": -65.0, "lat": -65.0 },
+          { "lon": 0.0, "lat": -65.0 },
+          { "lon": 0.0, "lat": 0.0 },
+          { "lon": -65.0, "lat": 0.0 },
+          { "lon": -65.0, "lat": -65.0 }
+        ]
+      }
+    ]
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/python.md
new file mode 100644
index 000000000..59f237f32
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/python.md
@@ -0,0 +1,57 @@
+```python
+models.FieldCondition(
+    key="location",
+    geo_polygon=models.GeoPolygon(
+        exterior=models.GeoLineString(
+            points=[
+                models.GeoPoint(
+                    lon=-70.0,
+                    lat=-70.0,
+                ),
+                models.GeoPoint(
+                    lon=60.0,
+                    lat=-70.0,
+                ),
+                models.GeoPoint(
+                    lon=60.0,
+                    lat=60.0,
+                ),
+                models.GeoPoint(
+                    lon=-70.0,
+                    lat=60.0,
+                ),
+                models.GeoPoint(
+                    lon=-70.0,
+                    lat=-70.0,
+                ),
+            ]
+        ),
+        interiors=[
+            models.GeoLineString(
+                points=[
+                    models.GeoPoint(
+                        lon=-65.0,
+                        lat=-65.0,
+                    ),
+                    models.GeoPoint(
+                        lon=0.0,
+                        lat=-65.0,
+                    ),
+                    models.GeoPoint(
+                        lon=0.0,
+                        lat=0.0,
+                    ),
+                    models.GeoPoint(
+                        lon=-65.0,
+                        lat=0.0,
+                    ),
+                    models.GeoPoint(
+                        lon=-65.0,
+                        lat=-65.0,
+                    ),
+                ]
+            )
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/rust.md
new file mode 100644
index 000000000..3df671fa8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/rust.md
@@ -0,0 +1,54 @@
+```rust
+use qdrant_client::qdrant::{Condition, GeoLineString, GeoPoint, GeoPolygon};
+
+Condition::geo_polygon(
+    "location",
+    GeoPolygon {
+        exterior: Some(GeoLineString {
+            points: vec![
+                GeoPoint {
+                    lon: -70.0,
+                    lat: -70.0,
+                },
+                GeoPoint {
+                    lon: 60.0,
+                    lat: -70.0,
+                },
+                GeoPoint {
+                    lon: 60.0,
+                    lat: 60.0,
+                },
+                GeoPoint {
+                    lon: -70.0,
+                    lat: 60.0,
+                },
+                GeoPoint {
+                    lon: -70.0,
+                    lat: -70.0,
+                },
+            ],
+        }),
+        interiors: vec![GeoLineString {
+            points: vec![
+                GeoPoint {
+                    lon: -65.0,
+                    lat: -65.0,
+                },
+                GeoPoint {
+                    lon: 0.0,
+                    lat: -65.0,
+                },
+                GeoPoint { lon: 0.0, lat: 0.0 },
+                GeoPoint {
+                    lon: -65.0,
+                    lat: 0.0,
+                },
+                GeoPoint {
+                    lon: -65.0,
+                    lat: -65.0,
+                },
+            ],
+        }],
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/typescript.md
new file mode 100644
index 000000000..6d69dadd5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-poligon/typescript.md
@@ -0,0 +1,57 @@
+```typescript
+{
+  key: "location",
+  geo_polygon: {
+    exterior: {
+      points: [
+        {
+          lon: -70.0,
+          lat: -70.0
+        },
+        {
+          lon: 60.0,
+          lat: -70.0
+        },
+        {
+          lon: 60.0,
+          lat: 60.0
+        },
+        {
+          lon: -70.0,
+          lat: 60.0
+        },
+        {
+          lon: -70.0,
+          lat: -70.0
+        }
+      ]
+    },
+    interiors: [
+      {
+        points: [
+          {
+            lon: -65.0,
+            lat: -65.0
+          },
+          {
+            lon: 0,
+            lat: -65.0
+          },
+          {
+            lon: 0,
+            lat: 0
+          },
+          {
+            lon: -65.0,
+            lat: 0
+          },
+          {
+            lon: -65.0,
+            lat: -65.0
+          }
+        ]
+      }
+    ]
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/_description.md
new file mode 100644
index 000000000..49be8bb00
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/_description.md
@@ -0,0 +1 @@
+This code snippet sets a filter condition based on a geographical radius. It specifies the center point with latitude and longitude coordinates, and sets a radius of 1000 meters from that center point.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/csharp.md
new file mode 100644
index 000000000..a59d95849
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+GeoRadius("location", 52.520711, 13.403683, 1000.0f);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/go.md
new file mode 100644
index 000000000..7fa0fcf92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewGeoRadius("location", 52.520711, 13.403683, 1000.0)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/java.md
new file mode 100644
index 000000000..c755d3715
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.geoRadius;
+
+geoRadius("location", 52.520711, 13.403683, 1000.0f);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/json.md
new file mode 100644
index 000000000..935e4fa40
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/json.md
@@ -0,0 +1,12 @@
+```json
+{
+  "key": "location",
+  "geo_radius": {
+    "center": {
+      "lon": 13.403683,
+      "lat": 52.520711
+    },
+    "radius": 1000.0
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/python.md
new file mode 100644
index 000000000..92f40fe97
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/python.md
@@ -0,0 +1,12 @@
+```python
+models.FieldCondition(
+    key="location",
+    geo_radius=models.GeoRadius(
+        center=models.GeoPoint(
+            lon=13.403683,
+            lat=52.520711,
+        ),
+        radius=1000.0,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/rust.md
new file mode 100644
index 000000000..9c2777270
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::qdrant::{Condition, GeoPoint, GeoRadius};
+
+Condition::geo_radius(
+    "location",
+    GeoRadius {
+        center: Some(GeoPoint {
+            lon: 13.403683,
+            lat: 52.520711,
+        }),
+        radius: 1000.0,
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/typescript.md
new file mode 100644
index 000000000..b46e6d92b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/geo-radius/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+{
+    key: 'location',
+    geo_radius: {
+        center: {
+            lon: 13.403683,
+            lat: 52.520711
+        },
+        radius: 1000.0
+    }    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/_description.md
new file mode 100644
index 000000000..9b26d1d43
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/_description.md
@@ -0,0 +1 @@
+This code represents a filtering condition where records can be checked for a specific field (in this case, "reports") if it is empty. This can help in filtering out records based on the absence of a value in the specified field.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/csharp.md
new file mode 100644
index 000000000..3222ce6ce
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/csharp.md
@@ -0,0 +1,6 @@
+```csharp
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+IsEmpty("reports");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/go.md
new file mode 100644
index 000000000..1feff6fad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewIsEmpty("reports")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/java.md
new file mode 100644
index 000000000..c6bdd7f34
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.isEmpty;
+
+isEmpty("reports");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/json.md
new file mode 100644
index 000000000..552c5c1d2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/json.md
@@ -0,0 +1,7 @@
+```json
+{
+  "is_empty": {
+    "key": "reports"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/python.md
new file mode 100644
index 000000000..d860b9a9b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/python.md
@@ -0,0 +1,5 @@
+```python
+models.IsEmptyCondition(
+    is_empty=models.PayloadField(key="reports"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/rust.md
new file mode 100644
index 000000000..81b65876a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/rust.md
@@ -0,0 +1,5 @@
+```rust
+use qdrant_client::qdrant::Condition;
+
+Condition::is_empty("reports")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/typescript.md
new file mode 100644
index 000000000..89abd7b51
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-empty/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+{
+  is_empty: {
+    key: "reports"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/_description.md
new file mode 100644
index 000000000..30a0e5d84
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/_description.md
@@ -0,0 +1 @@
+This code snippet defines an `IsNullCondition` to check if a specified field (`reports`) is NULL in a dataset. This condition is used to test for `NULL` values instead of using the `match` condition.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/csharp.md
new file mode 100644
index 000000000..309468d0c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/csharp.md
@@ -0,0 +1,6 @@
+```csharp
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+IsNull("reports");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/go.md
new file mode 100644
index 000000000..1fede580b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewIsNull("reports")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/java.md
new file mode 100644
index 000000000..87c4a8a0e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.isNull;
+
+isNull("reports");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/json.md
new file mode 100644
index 000000000..50403bf96
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/json.md
@@ -0,0 +1,7 @@
+```json
+{
+    "is_null": {
+        "key": "reports"
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/python.md
new file mode 100644
index 000000000..2148f1bf0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/python.md
@@ -0,0 +1,5 @@
+```python
+models.IsNullCondition(
+    is_null=models.PayloadField(key="reports"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/rust.md
new file mode 100644
index 000000000..f39594362
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/rust.md
@@ -0,0 +1,5 @@
+```rust
+use qdrant_client::qdrant::Condition;
+
+Condition::is_null("reports")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/typescript.md
new file mode 100644
index 000000000..c84bf48c2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/is-null/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+{
+  is_null: {
+    key: "reports"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/_description.md
new file mode 100644
index 000000000..c7da67adc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the use of the Match Any condition in a field filter. In this case, it checks if the value stored in the "color" field is either "black" or "yellow". The Match Any condition functions as a logical OR operation for the specified values, akin to the `IN` operator in databases.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/csharp.md
new file mode 100644
index 000000000..a362cb37a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+Match("color", ["black", "yellow"]);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/go.md
new file mode 100644
index 000000000..7b9aca20c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatchKeywords("color", "black", "yellow")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/java.md
new file mode 100644
index 000000000..95cfa897d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeywords;
+
+matchKeywords("color", List.of("black", "yellow"));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/json.md
new file mode 100644
index 000000000..b4abdbec9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "color",
+  "match": {
+    "any": ["black", "yellow"]
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/python.md
new file mode 100644
index 000000000..d476fe5d8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="color",
+    match=models.MatchAny(any=["black", "yellow"]),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/rust.md
new file mode 100644
index 000000000..28022d219
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/rust.md
@@ -0,0 +1,3 @@
+```rust
+Condition::matches("color", vec!["black".to_string(), "yellow".to_string()])
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/typescript.md
new file mode 100644
index 000000000..7f3bc5ec6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-any/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'color',
+    match: {any: ['black', 'yellow']}    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/_description.md
new file mode 100644
index 000000000..f556288f8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/_description.md
@@ -0,0 +1 @@
+This code snippet uses a `FieldCondition` with a `MatchExcept` condition for the key "color". It specifies that the condition should match values except "black" and "yellow". This is useful when you want to ensure that the stored value is not one of the specified values.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/csharp.md
new file mode 100644
index 000000000..a362cb37a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+Match("color", ["black", "yellow"]);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/go.md
new file mode 100644
index 000000000..1010f09cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatchExcept("color", "black", "yellow")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/java.md
new file mode 100644
index 000000000..9ad86b42c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchExceptKeywords;
+
+matchExceptKeywords("color", List.of("black", "yellow"));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/json.md
new file mode 100644
index 000000000..32a375773
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "color",
+  "match": {
+    "except": ["black", "yellow"]
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/python.md
new file mode 100644
index 000000000..95b64b917
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="color",
+    match=models.MatchExcept(**{"except": ["black", "yellow"]}),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/rust.md
new file mode 100644
index 000000000..93a085b4a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/rust.md
@@ -0,0 +1,8 @@
+```rust
+use qdrant_client::qdrant::r#match::MatchValue;
+
+Condition::matches(
+    "color",
+    !MatchValue::from(vec!["black".to_string(), "yellow".to_string()]),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/typescript.md
new file mode 100644
index 000000000..21961c2fd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-except/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'color',
+    match: {except: ['black', 'yellow']}
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/_description.md
new file mode 100644
index 000000000..664b5478b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/_description.md
@@ -0,0 +1 @@
+This code snippet defines a field condition specifying that the key is "count" and the matching value for the field is set to 0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/csharp.md
new file mode 100644
index 000000000..95c095c8e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+Match("count", 0);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/go.md
new file mode 100644
index 000000000..9a9541e82
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatchInt("count", 0)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/java.md
new file mode 100644
index 000000000..aa81e05eb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/java.md
@@ -0,0 +1,5 @@
+```java
+import static io.qdrant.client.ConditionFactory.match;
+
+match("count", 0);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/json.md
new file mode 100644
index 000000000..e70dee97d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "count",
+  "match": {
+    "value": 0
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/python.md
new file mode 100644
index 000000000..93724df2f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="count",
+    match=models.MatchValue(value=0),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/rust.md
new file mode 100644
index 000000000..8920a3a1f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/rust.md
@@ -0,0 +1,3 @@
+```rust
+Condition::matches("count", 0)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/typescript.md
new file mode 100644
index 000000000..debe808d6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-integer/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'count',
+    match: {value: 0}    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/_description.md
new file mode 100644
index 000000000..703c2d7a7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/_description.md
@@ -0,0 +1 @@
+This code snippet sets a filter condition to match records where the key is "color" and the value is "red".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/csharp.md
new file mode 100644
index 000000000..17f0d38a1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+MatchKeyword("color", "red");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/go.md
new file mode 100644
index 000000000..ebcc7353f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatch("color", "red")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/java.md
new file mode 100644
index 000000000..64dbd2ec2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/java.md
@@ -0,0 +1,3 @@
+```java
+matchKeyword("color", "red");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/json.md
new file mode 100644
index 000000000..4cef676d9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "color",
+  "match": {
+    "value": "red"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/python.md
new file mode 100644
index 000000000..7998ae859
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="color",
+    match=models.MatchValue(value="red"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/rust.md
new file mode 100644
index 000000000..a9f4b8244
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/rust.md
@@ -0,0 +1,3 @@
+```rust
+Condition::matches("color", "red".to_string())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/typescript.md
new file mode 100644
index 000000000..96f1b328f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-keyword/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'color', 
+    match: {value: 'red'}
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/_description.md
new file mode 100644
index 000000000..6cb56e87d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a field condition where the key is "uuid" and the value is set to a specific UUID value "f47ac10b-58cc-4372-a567-0e02b2c3d479" for matching purposes. It highlights the functionality of matching UUID values efficiently.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/csharp.md
new file mode 100644
index 000000000..1fc470c09
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+MatchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/go.md
new file mode 100644
index 000000000..79b65fcac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/go.md
@@ -0,0 +1,5 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewMatch("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/java.md
new file mode 100644
index 000000000..5e2d537d7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/java.md
@@ -0,0 +1,3 @@
+```java
+matchKeyword("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/json.md
new file mode 100644
index 000000000..4ddff3595
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "uuid",
+  "match": {
+    "value": "f47ac10b-58cc-4372-a567-0e02b2c3d479"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/python.md
new file mode 100644
index 000000000..d239a43c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="uuid",
+    match=models.MatchValue(value="f47ac10b-58cc-4372-a567-0e02b2c3d479"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/rust.md
new file mode 100644
index 000000000..1c13ff525
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/rust.md
@@ -0,0 +1,3 @@
+```rust
+Condition::matches("uuid", "f47ac10b-58cc-4372-a567-0e02b2c3d479".to_string())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/typescript.md
new file mode 100644
index 000000000..ce3ef281f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/match-uuid/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'uuid',
+    match: {value: 'f47ac10b-58cc-4372-a567-0e02b2c3d479'}    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/_description.md
new file mode 100644
index 000000000..075657032
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/_description.md
@@ -0,0 +1 @@
+This code snippet creates a field condition for the "price" key with a specified range. The range includes values greater than or equal to 100.0 and less than or equal to 450.0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/csharp.md
new file mode 100644
index 000000000..31e753e49
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/csharp.md
@@ -0,0 +1,5 @@
+```csharp
+using static Qdrant.Client.Grpc.Conditions;
+
+Range("price", new Qdrant.Client.Grpc.Range { Gte = 100.0, Lte = 450 });
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/go.md
new file mode 100644
index 000000000..05fe44dac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/go.md
@@ -0,0 +1,9 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewRange("price", &qdrant.Range{
+	Gte: qdrant.PtrOf(100.0),
+	Lte: qdrant.PtrOf(450.0),
+})
+
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/java.md
new file mode 100644
index 000000000..e9c0d6d3a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/java.md
@@ -0,0 +1,7 @@
+```java
+import static io.qdrant.client.ConditionFactory.range;
+
+import io.qdrant.client.grpc.Points.Range;
+
+range("price", Range.newBuilder().setGte(100.0).setLte(450).build());
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/json.md
new file mode 100644
index 000000000..9dd887ae7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/json.md
@@ -0,0 +1,11 @@
+```json
+{
+  "key": "price",
+  "range": {
+    "gt": null,
+    "gte": 100.0,
+    "lt": null,
+    "lte": 450.0
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/python.md
new file mode 100644
index 000000000..7722cd98e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/python.md
@@ -0,0 +1,11 @@
+```python
+models.FieldCondition(
+    key="price",
+    range=models.Range(
+        gt=None,
+        gte=100.0,
+        lt=None,
+        lte=450.0,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/rust.md
new file mode 100644
index 000000000..520e6818d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{Condition, Range};
+
+Condition::range(
+    "price",
+    Range {
+        gt: None,
+        gte: Some(100.0),
+        lt: None,
+        lte: Some(450.0),
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/typescript.md
new file mode 100644
index 000000000..7ca9960d2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/range/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+{
+    key: 'price',
+    range: {
+        gt: null,
+        gte: 100.0,
+        lt: null,
+        lte: 450.0    
+    }    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/_description.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/_description.md
new file mode 100644
index 000000000..fca3564b3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/_description.md
@@ -0,0 +1 @@
+This code defines a filter condition for a field named "comments" where the search will only consider items with more than two comments.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/csharp.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/csharp.md
new file mode 100644
index 000000000..f9646b718
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/csharp.md
@@ -0,0 +1,6 @@
+```csharp
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+ValuesCount("comments", new ValuesCount { Gt = 2 });
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/go.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/go.md
new file mode 100644
index 000000000..005961927
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/go.md
@@ -0,0 +1,7 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.NewValuesCount("comments", &qdrant.ValuesCount{
+	Gt: qdrant.PtrOf(uint64(2)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/java.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/java.md
new file mode 100644
index 000000000..86626a1e4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/java.md
@@ -0,0 +1,7 @@
+```java
+import static io.qdrant.client.ConditionFactory.valuesCount;
+
+import io.qdrant.client.grpc.Points.ValuesCount;
+
+valuesCount("comments", ValuesCount.newBuilder().setGt(2).build());
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/json.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/json.md
new file mode 100644
index 000000000..b777b960d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/json.md
@@ -0,0 +1,8 @@
+```json
+{
+  "key": "comments",
+  "values_count": {
+    "gt": 2
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/python.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/python.md
new file mode 100644
index 000000000..3c1d48581
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/python.md
@@ -0,0 +1,6 @@
+```python
+models.FieldCondition(
+    key="comments",
+    values_count=models.ValuesCount(gt=2),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/rust.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/rust.md
new file mode 100644
index 000000000..3b7663dba
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::{Condition, ValuesCount};
+
+Condition::values_count(
+    "comments",
+    ValuesCount {
+        gt: Some(2),
+        ..Default::default()
+    },
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/typescript.md b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/typescript.md
new file mode 100644
index 000000000..41b108382
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/filter-condition/values-count/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+{
+    key: 'comments',
+    values_count: {gt: 2}    
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/_description.md
new file mode 100644
index 000000000..57e084b67
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/_description.md
@@ -0,0 +1 @@
+You can efficiently upload multiple points into Qdrant with a single API call using batching. This snippet demonstrates the process of creating new points with a batch operation. The batch contains IDs, payloads (such as color information), and vectors for each point. By grouping points together, you can reduce network connection overhead and improve performance.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/http.md
new file mode 100644
index 000000000..b614a270c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/http.md
@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "batch": {
+        "ids": [1, 2, 3],
+        "payloads": [
+            {"color": "red"},
+            {"color": "green"},
+            {"color": "blue"}
+        ],
+        "vectors": [
+            [0.9, 0.1, 0.1],
+            [0.1, 0.9, 0.1],
+            [0.1, 0.1, 0.9]
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/python.md
new file mode 100644
index 000000000..eed2a4c33
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/python.md
@@ -0,0 +1,18 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=models.Batch(
+        ids=[1, 2, 3],
+        payloads=[
+            {"color": "red"},
+            {"color": "green"},
+            {"color": "blue"},
+        ],
+        vectors=[
+            [0.9, 0.1, 0.1],
+            [0.1, 0.9, 0.1],
+            [0.1, 0.1, 0.9],
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/typescript.md
new file mode 100644
index 000000000..656e8a062
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/batch-simple/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+client.upsert("{collection_name}", {
+  batch: {
+    ids: [1, 2, 3],
+    payloads: [{ color: "red" }, { color: "green" }, { color: "blue" }],
+    vectors: [
+      [0.9, 0.1, 0.1],
+      [0.1, 0.9, 0.1],
+      [0.1, 0.1, 0.9],
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/_description.md
new file mode 100644
index 000000000..3cbd48b0d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/_description.md
@@ -0,0 +1 @@
+This code snippet represents a functionality to update points in a collection. In this instance, it updates a point with id 1 by changing its payload to have a color of "red" and its vector coordinates to [0.9, 0.1, 0.1].
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/csharp.md
new file mode 100644
index 000000000..b01296f5a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
+			Payload = { ["color"] = "Red" }
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/go.md
new file mode 100644
index 000000000..6441ff605
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
+			Payload: qdrant.NewValueMap(map[string]any{"color": "Red"}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/http.md
new file mode 100644
index 000000000..32e9a9a9c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "payload": {"color": "red"},
+            "vector": [0.9, 0.1, 0.1]
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/java.md
new file mode 100644
index 000000000..93b7b5163
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/java.md
@@ -0,0 +1,26 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
+                .putAllPayload(Map.of("color", value("Red")))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/python.md
new file mode 100644
index 000000000..f8d3a44b3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/python.md
@@ -0,0 +1,14 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            payload={
+                "color": "red",
+            },
+            vector=[0.9, 0.1, 0.1],
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/rust.md
new file mode 100644
index 000000000..bb4a6c2f5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![PointStruct::new(
+                1,
+                vec![0.9, 0.1, 0.1],
+                [("color", "Red".into())],
+            )],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/typescript.md
new file mode 100644
index 000000000..9b1db8d9d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/int-one-point-simple/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      payload: {
+        color: "red",
+      },
+      vector: [0.9, 0.1, 0.1],
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/_description.md
new file mode 100644
index 000000000..3c63944cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/_description.md
@@ -0,0 +1 @@
+Inserts a list of points along with their IDs, payload data (such as color), and vector coordinates into a collection for storage or processing. The points are structured as objects with different attributes like ID, payload, and vector to represent properties of each point.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/csharp.md
new file mode 100644
index 000000000..a2738066b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/csharp.md
@@ -0,0 +1,31 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new[] { 0.9f, 0.1f, 0.1f },
+			Payload = { ["color"] = "red" }
+		},
+		new()
+		{
+			Id = 2,
+			Vectors = new[] { 0.1f, 0.9f, 0.1f },
+			Payload = { ["color"] = "green" }
+		},
+		new()
+		{
+			Id = 3,
+			Vectors = new[] { 0.1f, 0.1f, 0.9f },
+			Payload = { ["color"] = "blue" }
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/go.md
new file mode 100644
index 000000000..62d759e35
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/go.md
@@ -0,0 +1,33 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectors(0.9, 0.1, 0.1),
+			Payload: qdrant.NewValueMap(map[string]any{"color": "red"}),
+		},
+		{
+			Id:      qdrant.NewIDNum(2),
+			Vectors: qdrant.NewVectors(0.1, 0.9, 0.1),
+			Payload: qdrant.NewValueMap(map[string]any{"color": "green"}),
+		},
+		{
+			Id:      qdrant.NewIDNum(3),
+			Vectors: qdrant.NewVectors(0.1, 0.1, 0.9),
+			Payload: qdrant.NewValueMap(map[string]any{"color": "blue"}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/http.md
new file mode 100644
index 000000000..bb2f95270
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/http.md
@@ -0,0 +1,22 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "payload": {"color": "red"},
+            "vector": [0.9, 0.1, 0.1]
+        },
+        {
+            "id": 2,
+            "payload": {"color": "green"},
+            "vector": [0.1, 0.9, 0.1]
+        },
+        {
+            "id": 3,
+            "payload": {"color": "blue"},
+            "vector": [0.1, 0.1, 0.9]
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/java.md
new file mode 100644
index 000000000..2264ce291
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/java.md
@@ -0,0 +1,36 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(vectors(0.9f, 0.1f, 0.1f))
+                .putAllPayload(Map.of("color", value("red")))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(2))
+                .setVectors(vectors(0.1f, 0.9f, 0.1f))
+                .putAllPayload(Map.of("color", value("green")))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(3))
+                .setVectors(vectors(0.1f, 0.1f, 0.9f))
+                .putAllPayload(Map.of("color", value("blue")))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/python.md
new file mode 100644
index 000000000..39d68b65e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/python.md
@@ -0,0 +1,28 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            payload={
+                "color": "red",
+            },
+            vector=[0.9, 0.1, 0.1],
+        ),
+        models.PointStruct(
+            id=2,
+            payload={
+                "color": "green",
+            },
+            vector=[0.1, 0.9, 0.1],
+        ),
+        models.PointStruct(
+            id=3,
+            payload={
+                "color": "blue",
+            },
+            vector=[0.1, 0.1, 0.9],
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/rust.md
new file mode 100644
index 000000000..1bf90d8a5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointStruct::new(1, vec![0.9, 0.1, 0.1], [("city", "red".into())]),
+                PointStruct::new(2, vec![0.1, 0.9, 0.1], [("city", "green".into())]),
+                PointStruct::new(3, vec![0.1, 0.1, 0.9], [("city", "blue".into())]),
+            ],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/typescript.md
new file mode 100644
index 000000000..d79b7362d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/list-of-points-simple/typescript.md
@@ -0,0 +1,21 @@
+```typescript
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      payload: { color: "red" },
+      vector: [0.9, 0.1, 0.1],
+    },
+    {
+      id: 2,
+      payload: { color: "green" },
+      vector: [0.1, 0.9, 0.1],
+    },
+    {
+      id: 3,
+      payload: { color: "blue" },
+      vector: [0.1, 0.1, 0.9],
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/_description.md
new file mode 100644
index 000000000..88b8033e5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/_description.md
@@ -0,0 +1 @@
+This code snippet allows inserting a point with named vectors into a collection. The point has an ID and contains vectors labeled as "image," "text," and "text-sparse." The "image" vector has four values, the "text" vector has five values, and the "text-sparse" vector includes indices and corresponding values.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/csharp.md
new file mode 100644
index 000000000..25ea2341d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/csharp.md
@@ -0,0 +1,25 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Dictionary<string, Vector>
+            {
+                ["image"] = new() {
+                    Data = {0.9f, 0.1f, 0.1f, 0.2f}
+                },
+                ["text"] = new() {
+                    Data = {0.4f, 0.7f, 0.1f, 0.8f, 0.1f}
+                },
+                ["text-sparse"] = ([0.1f, 0.2f, 0.3f, 0.4f], [1, 3, 5, 7]),
+            }
+        }
+    }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/go.md
new file mode 100644
index 000000000..dc3f35e0e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"image": qdrant.NewVector(0.9, 0.1, 0.1, 0.2),
+				"text":  qdrant.NewVector(0.4, 0.7, 0.1, 0.8, 0.1),
+				"text-sparse": qdrant.NewVectorSparse(
+					[]uint32{1, 3, 5, 7},
+					[]float32{0.1, 0.2, 0.3, 0.4}),
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/http.md
new file mode 100644
index 000000000..399a5cb32
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/http.md
@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}/points?wait=true
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": {
+                "image": [0.9, 0.1, 0.1, 0.2],
+                "text": [0.4, 0.7, 0.1, 0.8, 0.1],
+                "text-sparse": {
+                  "indices": [1, 3, 5, 7],
+                  "values": [0.1, 0.2, 0.3, 0.4]
+                }
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/java.md
new file mode 100644
index 000000000..c72edf67f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/java.md
@@ -0,0 +1,28 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorFactory.vector;
+import static io.qdrant.client.VectorsFactory.namedVectors;
+
+import io.qdrant.client.grpc.Points.PointStruct;
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "image",
+                            vector(List.of(0.9f, 0.1f, 0.1f, 0.2f)),
+                            "text",
+                            vector(List.of(0.4f, 0.7f, 0.1f, 0.8f, 0.1f)),
+                            "text-sparse",
+                            vector(List.of(0.1f, 0.2f, 0.3f, 0.4f), List.of(1, 3, 5, 7)))))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/python.md
new file mode 100644
index 000000000..50f487e39
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/python.md
@@ -0,0 +1,18 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector={
+                "image": [0.9, 0.1, 0.1, 0.2],
+                "text": [0.4, 0.7, 0.1, 0.8, 0.1],
+                "text-sparse": {
+                    "indices": [1, 3, 5, 7],
+                    "values": [0.1, 0.2, 0.3, 0.4],
+                },
+            },
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/rust.md
new file mode 100644
index 000000000..838dffbe4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/rust.md
@@ -0,0 +1,27 @@
+```rust
+
+use qdrant_client::qdrant::{
+    NamedVectors, PointStruct, UpsertPointsBuilder, Vector,
+};
+use qdrant_client::Payload;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![PointStruct::new(
+                1,
+                NamedVectors::default()
+                    .add_vector("text", Vector::new_dense(vec![0.4, 0.7, 0.1, 0.8, 0.1]))
+                    .add_vector("image", Vector::new_dense(vec![0.9, 0.1, 0.1, 0.2]))
+                    .add_vector(
+                        "text-sparse",
+                        Vector::new_sparse(vec![1, 3, 5, 7], vec![0.1, 0.2, 0.3, 0.4]),
+                    ),
+                Payload::default(),
+            )],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/typescript.md
new file mode 100644
index 000000000..c337d3fd6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/named-vectors/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+client.upsert("{collection_name}", {
+    points: [
+        {
+            id: 1,
+            vector: {
+                image: [0.9, 0.1, 0.1, 0.2],
+                text: [0.4, 0.7, 0.1, 0.8, 0.1],
+                text_sparse: {
+                    indices: [1, 3, 5, 7],
+                    values: [0.1, 0.2, 0.3, 0.4]
+                }
+            },
+        },
+    ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/_description.md
new file mode 100644
index 000000000..81321cb58
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/_description.md
@@ -0,0 +1 @@
+Inserts a point with a sparse vector, identified by its ID and containing indices and corresponding values, into the specified collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/csharp.md
new file mode 100644
index 000000000..d8b13e764
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/csharp.md
@@ -0,0 +1,18 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+  collectionName: "{collection_name}",
+  points: new List < PointStruct > {
+    new() {
+      Id = 1,
+        Vectors = new Dictionary <string, Vector> {
+          ["text"] = ([0.1f, 0.2f, 0.3f, 0.4f], [1, 3, 5, 7])
+        }
+    }
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/go.md
new file mode 100644
index 000000000..bff022bea
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMap(
+				map[string]*qdrant.Vector{
+					"text": qdrant.NewVectorSparse(
+						[]uint32{1, 3, 5, 7},
+						[]float32{0.1, 0.2, 0.3, 0.4}),
+				}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/http.md
new file mode 100644
index 000000000..ac6c31aa1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/http.md
@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": {
+                "text": {
+                    "indices": [1, 3, 5, 7],
+                    "values": [0.1, 0.2, 0.3, 0.4]
+                }
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/java.md
new file mode 100644
index 000000000..e69dba1a8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/java.md
@@ -0,0 +1,28 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorFactory.vector;
+import static io.qdrant.client.VectorsFactory.namedVectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+  .upsertAsync(
+    "{collection_name}",
+    List.of(
+      PointStruct.newBuilder()
+      .setId(id(1))
+      .setVectors(
+        namedVectors(Map.of(
+          "text", vector(List.of(1.0f, 2.0f), List.of(6, 7))))
+      )
+      .build()))
+  .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/python.md
new file mode 100644
index 000000000..5fbecd4b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/python.md
@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            payload={},  # Add any additional payload if necessary
+            vector={
+                "text": models.SparseVector(
+                    indices=[1, 3, 5, 7],
+                    values=[0.1, 0.2, 0.3, 0.4]
+                )
+            },
+        )
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/rust.md
new file mode 100644
index 000000000..59b735796
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{NamedVectors, PointStruct, UpsertPointsBuilder, Vector};
+
+use qdrant_client::{Payload, Qdrant};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let points = vec![PointStruct::new(
+    1,
+    NamedVectors::default().add_vector(
+        "text",
+        Vector::new_sparse(vec![1, 3, 5, 7], vec![0.1, 0.2, 0.3, 0.4]),
+    ),
+    Payload::new(),
+)];
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}", points))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/typescript.md
new file mode 100644
index 000000000..342382be8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors-single/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: {
+        text: {
+          indices: [1, 3, 5, 7],
+          values: [0.1, 0.2, 0.3, 0.4]
+        },
+      },
+    }
+  ]
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/_description.md
new file mode 100644
index 000000000..a84581463
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a system for inserting points with sparse vectors into collections. Each point consists of an ID and a vector, where the vector data includes the indices and corresponding values. The `indices` and `values` arrays are required to have the same length, with unique `indices`. If the `indices` are not sorted, the system will internally sort them. Sparse vectors can be uploaded in a similar manner as dense vectors.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/csharp.md
new file mode 100644
index 000000000..e7a1a8d5b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/csharp.md
@@ -0,0 +1,26 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new Dictionary<string, Vector> { ["text"] = ([1.0f, 2.0f], [6, 7]) }
+		},
+		new()
+		{
+			Id = 2,
+			Vectors = new Dictionary<string, Vector>
+			{
+				["text"] = ([0.1f, 0.2f, 0.3f, 0.4f, 0.5f], [1, 2, 3, 4, 5])
+			}
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/go.md
new file mode 100644
index 000000000..15f85c17a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/go.md
@@ -0,0 +1,34 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"text": qdrant.NewVectorSparse(
+					[]uint32{6, 7},
+					[]float32{1.0, 2.0}),
+			}),
+		},
+		{
+			Id: qdrant.NewIDNum(2),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"text": qdrant.NewVectorSparse(
+					[]uint32{1, 2, 3, 4, 5},
+					[]float32{0.1, 0.2, 0.3, 0.4, 0.5}),
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/http.md
new file mode 100644
index 000000000..7a50739c4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/http.md
@@ -0,0 +1,25 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": {
+                "text": {
+                    "indices": [6, 7],
+                    "values": [1.0, 2.0]
+                }
+            }
+        },
+        {
+            "id": 2,
+            "vector": {
+                "text": {
+                    "indices": [1, 1, 2, 3, 4, 5],
+                    "values": [0.1, 0.2, 0.3, 0.4, 0.5]
+                }
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/java.md
new file mode 100644
index 000000000..d430cfccb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/java.md
@@ -0,0 +1,44 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorFactory.vector;
+
+import io.qdrant.client.grpc.Points.NamedVectors;
+import io.qdrant.client.grpc.Points.PointStruct;
+import io.qdrant.client.grpc.Points.Vectors;
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    Vectors.newBuilder()
+                        .setVectors(
+                            NamedVectors.newBuilder()
+                                .putAllVectors(
+                                    Map.of(
+                                        "text", vector(List.of(1.0f, 2.0f), List.of(6, 7))))
+                                .build())
+                        .build())
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(2))
+                .setVectors(
+                    Vectors.newBuilder()
+                        .setVectors(
+                            NamedVectors.newBuilder()
+                                .putAllVectors(
+                                    Map.of(
+                                        "text",
+                                        vector(
+                                            List.of(0.1f, 0.2f, 0.3f, 0.4f, 0.5f),
+                                            List.of(1, 2, 3, 4, 5))))
+                                .build())
+                        .build())
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/python.md
new file mode 100644
index 000000000..583dc703f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/python.md
@@ -0,0 +1,25 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector={
+                "text": models.SparseVector(
+                    indices=[6, 7],
+                    values=[1.0, 2.0],
+                )
+            },
+        ),
+        models.PointStruct(
+            id=2,
+            vector={
+                "text": models.SparseVector(
+                    indices=[1, 2, 3, 4, 5],
+                    values=[0.1, 0.2, 0.3, 0.4, 0.5],
+                )
+            },
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/rust.md
new file mode 100644
index 000000000..0ea2bc4bc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/rust.md
@@ -0,0 +1,30 @@
+```rust
+use std::collections::HashMap;
+
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder, Vector};
+use qdrant_client::Payload;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointStruct::new(
+                    1,
+                    HashMap::from([("text".to_string(), vec![(6, 1.0), (7, 2.0)])]),
+                    Payload::default(),
+                ),
+                PointStruct::new(
+                    2,
+                    HashMap::from([(
+                        "text".to_string(),
+                        vec![(1, 0.1), (2, 0.2), (3, 0.3), (4, 0.4), (5, 0.5)],
+                    )]),
+                    Payload::default(),
+                ),
+            ],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/typescript.md
new file mode 100644
index 000000000..8bbf752ff
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/sparse-vectors/typescript.md
@@ -0,0 +1,24 @@
+```typescript
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: {
+        text: {
+          indices: [6, 7],
+          values: [1.0, 2.0],
+        },
+      },
+    },
+    {
+      id: 2,
+      vector: {
+        text: {
+          indices: [1, 2, 3, 4, 5],
+          values: [0.1, 0.2, 0.3, 0.4, 0.5],
+        },
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/_description.md
new file mode 100644
index 000000000..d0820041c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/_description.md
@@ -0,0 +1 @@
+This code snippet allows you to insert a point with a specific ID into a collection. The point contains a payload with color information and a vector represented by an array of three values. The ID of the point is a UUID, which can be used as a unique identifier for the point within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/csharp.md
new file mode 100644
index 000000000..eda75b64d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = Guid.Parse("5c56c793-69f3-4fbf-87e6-c4bf54c28c26"),
+			Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
+			Payload = { ["color"] = "Red" }
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/go.md
new file mode 100644
index 000000000..dff9d8198
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewID("5c56c793-69f3-4fbf-87e6-c4bf54c28c26"),
+			Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
+			Payload: qdrant.NewValueMap(map[string]any{"color": "Red"}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/http.md
new file mode 100644
index 000000000..093bb1f53
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
+            "payload": {"color": "red"},
+            "vector": [0.9, 0.1, 0.1]
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/java.md
new file mode 100644
index 000000000..575e27d55
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/java.md
@@ -0,0 +1,27 @@
+```java
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(UUID.fromString("5c56c793-69f3-4fbf-87e6-c4bf54c28c26")))
+                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
+                .putAllPayload(Map.of("color", value("Red")))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/python.md
new file mode 100644
index 000000000..1f7ea92cb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/python.md
@@ -0,0 +1,18 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id="5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
+            payload={
+                "color": "red",
+            },
+            vector=[0.9, 0.1, 0.1],
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/rust.md
new file mode 100644
index 000000000..81fa92ef6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![PointStruct::new(
+                "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
+                vec![0.9, 0.1, 0.1],
+                [("color", "Red".into())],
+            )],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/typescript.md
new file mode 100644
index 000000000..da09d6f0f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/uuid-one-point-simple/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: "5c56c793-69f3-4fbf-87e6-c4bf54c28c26",
+      payload: {
+        color: "red",
+      },
+      vector: [0.9, 0.1, 0.1],
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/_description.md
new file mode 100644
index 000000000..7a1cafc1e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the insertion of points with multiple vectors into a collection. Each point has an id associated with it, along with vectors containing numerical values. The vectors are named 'image' and 'text' and consist of arrays of floating-point numbers. The API request uses the PUT method to upload the point data. Qdrant's idempotent nature ensures that re-uploading points with the same id will overwrite existing data, providing data consistency even in environments like message queues that lack exactly-once delivery guarantees. This feature is available starting from version 0.10.0.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/csharp.md
new file mode 100644
index 000000000..92032c608
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/csharp.md
@@ -0,0 +1,31 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new Dictionary<string, float[]>
+			{
+				["image"] = [0.9f, 0.1f, 0.1f, 0.2f],
+				["text"] = [0.4f, 0.7f, 0.1f, 0.8f, 0.1f, 0.1f, 0.9f, 0.2f]
+			}
+		},
+		new()
+		{
+			Id = 2,
+			Vectors = new Dictionary<string, float[]>
+			{
+				["image"] = [0.2f, 0.1f, 0.3f, 0.9f],
+				["text"] = [0.5f, 0.2f, 0.7f, 0.4f, 0.7f, 0.2f, 0.3f, 0.9f]
+			}
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/go.md
new file mode 100644
index 000000000..643b76883
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/go.md
@@ -0,0 +1,32 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"image": qdrant.NewVector(0.9, 0.1, 0.1, 0.2),
+				"text":  qdrant.NewVector(0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2),
+			}),
+		},
+		{
+			Id: qdrant.NewIDNum(2),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"image": qdrant.NewVector(0.2, 0.1, 0.3, 0.9),
+				"text":  qdrant.NewVector(0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9),
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/http.md
new file mode 100644
index 000000000..9c13776be
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/http.md
@@ -0,0 +1,21 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": {
+                "image": [0.9, 0.1, 0.1, 0.2],
+                "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2]
+            }
+        },
+        {
+            "id": 2,
+            "vector": {
+                "image": [0.2, 0.1, 0.3, 0.9],
+                "text": [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9]
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/java.md
new file mode 100644
index 000000000..5df50f261
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/java.md
@@ -0,0 +1,36 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorFactory.vector;
+import static io.qdrant.client.VectorsFactory.namedVectors;
+
+import io.qdrant.client.grpc.Points.PointStruct;
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "image",
+                            vector(List.of(0.9f, 0.1f, 0.1f, 0.2f)),
+                            "text",
+                            vector(List.of(0.4f, 0.7f, 0.1f, 0.8f, 0.1f, 0.1f, 0.9f, 0.2f)))))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(2))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "image",
+                            List.of(0.2f, 0.1f, 0.3f, 0.9f),
+                            "text",
+                            List.of(0.5f, 0.2f, 0.7f, 0.4f, 0.7f, 0.2f, 0.3f, 0.9f))))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/python.md
new file mode 100644
index 000000000..0db32926d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/python.md
@@ -0,0 +1,21 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector={
+                "image": [0.9, 0.1, 0.1, 0.2],
+                "text": [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
+            },
+        ),
+        models.PointStruct(
+            id=2,
+            vector={
+                "image": [0.2, 0.1, 0.3, 0.9],
+                "text": [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
+            },
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/rust.md
new file mode 100644
index 000000000..2d7f15d2f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/rust.md
@@ -0,0 +1,39 @@
+```rust
+use std::collections::HashMap;
+
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Payload;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointStruct::new(
+                    1,
+                    HashMap::from([
+                        ("image".to_string(), vec![0.9, 0.1, 0.1, 0.2]),
+                        (
+                            "text".to_string(),
+                            vec![0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
+                        ),
+                    ]),
+                    Payload::default(),
+                ),
+                PointStruct::new(
+                    2,
+                    HashMap::from([
+                        ("image".to_string(), vec![0.2, 0.1, 0.3, 0.9]),
+                        (
+                            "text".to_string(),
+                            vec![0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
+                        ),
+                    ]),
+                    Payload::default(),
+                ),
+            ],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/typescript.md
new file mode 100644
index 000000000..f482fc702
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multiple-vectors/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: {
+        image: [0.9, 0.1, 0.1, 0.2],
+        text: [0.4, 0.7, 0.1, 0.8, 0.1, 0.1, 0.9, 0.2],
+      },
+    },
+    {
+      id: 2,
+      vector: {
+        image: [0.2, 0.1, 0.3, 0.9],
+        text: [0.5, 0.2, 0.7, 0.4, 0.7, 0.2, 0.3, 0.9],
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/_description.md
new file mode 100644
index 000000000..0de3ad6e2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/_description.md
@@ -0,0 +1 @@
+This code snippet is for inserting a point with a multivector into a collection. It defines an operation to update a collection with a new point containing an ID and a vector represented by multiple arrays of values.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/csharp.md
new file mode 100644
index 000000000..4e1afd14a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/csharp.md
@@ -0,0 +1,20 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+  collectionName: "{collection_name}",
+  points: new List <PointStruct> {
+    new() {
+      Id = 1,
+        Vectors = new float[][] {
+          [-0.013f, 0.020f, -0.007f, -0.111f],
+          [-0.030f, -0.05f, 0.001f, 0.072f],
+          [-0.041f, 0.014f, -0.032f, -0.062f ],
+        },
+    },
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/go.md
new file mode 100644
index 000000000..9144c5bef
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMulti(
+				[][]float32{
+					{-0.013, 0.020, -0.007, -0.111},
+					{-0.030, -0.055, 0.001, 0.072},
+					{-0.041, 0.014, -0.032, -0.062}}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/http.md
new file mode 100644
index 000000000..8ae1c4395
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/http.md
@@ -0,0 +1,15 @@
+```http
+PUT collections/{collection_name}/points
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": [
+        [-0.013,  0.020, -0.007, -0.111, ...],
+        [-0.030, -0.055,  0.001,  0.072, ...],
+        [-0.041,  0.014, -0.032, -0.062, ...]
+      ]
+    }
+  ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/java.md
new file mode 100644
index 000000000..1f47a2ab8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/java.md
@@ -0,0 +1,29 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorsFactory.vectors;
+import static io.qdrant.client.VectorFactory.multiVector;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+.upsertAsync(
+    "{collection_name}",
+    List.of(
+        PointStruct.newBuilder()
+            .setId(id(1))
+            .setVectors(vectors(multiVector(new float[][] {
+                {-0.013f,  0.020f, -0.007f, -0.111f},
+                {-0.030f, -0.055f,  0.001f,  0.072f},
+                {-0.041f,  0.014f, -0.032f, -0.062f}
+            })))
+            .build()
+    ))
+.get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/python.md
new file mode 100644
index 000000000..06ebc9b1d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/python.md
@@ -0,0 +1,19 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector=[
+                [-0.013,  0.020, -0.007, -0.111],
+                [-0.030, -0.055,  0.001,  0.072],
+                [-0.041,  0.014, -0.032, -0.062]
+            ],
+        )
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/rust.md
new file mode 100644
index 000000000..336794267
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/rust.md
@@ -0,0 +1,24 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder, Vector};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let points = vec![
+    PointStruct::new(
+        1,
+        Vector::new_multi(vec![
+            vec![-0.013, 0.020, -0.007, -0.111],
+            vec![-0.030, -0.055, 0.001, 0.072],
+            vec![-0.041, 0.014, -0.032, -0.062],
+        ]),
+        Payload::new()
+    )
+];
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new("{collection_name}", points)
+    ).await?;
+
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/typescript.md
new file mode 100644
index 000000000..25055107e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-multivector/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: [
+        [-0.013,  0.020, -0.007, -0.111, ...],
+        [-0.030, -0.055,  0.001,  0.072, ...],
+        [-0.041,  0.014, -0.032, -0.062, ...]
+      ],
+    }
+  ]
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/_description.md
new file mode 100644
index 000000000..574f520cc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to insert multiple points with additional payload data into a collection. Each point is defined by an ID, a vector, and a payload containing information such as city names and prices. The `PUT` request is used to send this data to the server for storage or further processing.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/csharp.md
new file mode 100644
index 000000000..521578d69
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/csharp.md
@@ -0,0 +1,38 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new PointStruct
+        {
+            Id = 1,
+            Vectors = new[] { 0.05f, 0.61f, 0.76f, 0.74f },
+            Payload = { ["city"] = "Berlin", ["price"] = 1.99 }
+        },
+        new PointStruct
+        {
+            Id = 2,
+            Vectors = new[] { 0.19f, 0.81f, 0.75f, 0.11f },
+            Payload = { ["city"] = new[] { "Berlin", "London" } }
+        },
+        new PointStruct
+        {
+            Id = 3,
+            Vectors = new[] { 0.36f, 0.55f, 0.47f, 0.94f },
+            Payload =
+            {
+                ["city"] = new[] { "Berlin", "Moscow" },
+                ["price"] = new Value
+                {
+                    ListValue = new ListValue { Values = { new Value[] { 1.99, 2.99 } } }
+                }
+            }
+        }
+    }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/go.md
new file mode 100644
index 000000000..dc8e1b557
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/go.md
@@ -0,0 +1,37 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+    CollectionName: "{collection_name}",
+    Points: []*qdrant.PointStruct{
+        {
+            Id:      qdrant.NewIDNum(1),
+            Vectors: qdrant.NewVectors(0.05, 0.61, 0.76, 0.74),
+            Payload: qdrant.NewValueMap(map[string]any{
+                "city": "Berlin", "price": 1.99}),
+        },
+        {
+            Id:      qdrant.NewIDNum(2),
+            Vectors: qdrant.NewVectors(0.19, 0.81, 0.75, 0.11),
+            Payload: qdrant.NewValueMap(map[string]any{
+                "city": []any{"Berlin", "London"}}),
+        },
+        {
+            Id:      qdrant.NewIDNum(3),
+            Vectors: qdrant.NewVectors(0.36, 0.55, 0.47, 0.94),
+            Payload: qdrant.NewValueMap(map[string]any{
+                "city":  []any{"Berlin", "London"},
+                "price": []any{1.99, 2.99}}),
+        },
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/http.md
new file mode 100644
index 000000000..cf31f344f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/http.md
@@ -0,0 +1,22 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": [0.05, 0.61, 0.76, 0.74],
+            "payload": {"city": "Berlin", "price": 1.99}
+        },
+        {
+            "id": 2,
+            "vector": [0.19, 0.81, 0.75, 0.11],
+            "payload": {"city": ["Berlin", "London"], "price": 1.99}
+        },
+        {
+            "id": 3,
+            "vector": [0.36, 0.55, 0.47, 0.94],
+            "payload": {"city": ["Berlin", "Moscow"], "price": [1.99, 2.99]}
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/java.md
new file mode 100644
index 000000000..c8b276098
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/java.md
@@ -0,0 +1,42 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(vectors(0.05f, 0.61f, 0.76f, 0.74f))
+                .putAllPayload(Map.of("city", value("Berlin"), "price", value(1.99)))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(2))
+                .setVectors(vectors(0.19f, 0.81f, 0.75f, 0.11f))
+                .putAllPayload(
+                    Map.of("city", list(List.of(value("Berlin"), value("London")))))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(3))
+                .setVectors(vectors(0.36f, 0.55f, 0.47f, 0.94f))
+                .putAllPayload(
+                    Map.of(
+                        "city",
+                        list(List.of(value("Berlin"), value("London"))),
+                        "price",
+                        list(List.of(value(1.99), value(2.99)))))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/python.md
new file mode 100644
index 000000000..419dd6e98
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/python.md
@@ -0,0 +1,35 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector=[0.05, 0.61, 0.76, 0.74],
+            payload={
+                "city": "Berlin",
+                "price": 1.99,
+            },
+        ),
+        models.PointStruct(
+            id=2,
+            vector=[0.19, 0.81, 0.75, 0.11],
+            payload={
+                "city": ["Berlin", "London"],
+                "price": 1.99,
+            },
+        ),
+        models.PointStruct(
+            id=3,
+            vector=[0.36, 0.55, 0.47, 0.94],
+            payload={
+                "city": ["Berlin", "Moscow"],
+                "price": [1.99, 2.99],
+            },
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/rust.md
new file mode 100644
index 000000000..a53ab5434
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/rust.md
@@ -0,0 +1,30 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::{Payload, Qdrant, QdrantError};
+use serde_json::json;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let points = vec![
+    PointStruct::new(
+        1,
+        vec![0.05, 0.61, 0.76, 0.74],
+        Payload::try_from(json!({"city": "Berlin", "price": 1.99})).unwrap(),
+    ),
+    PointStruct::new(
+        2,
+        vec![0.19, 0.81, 0.75, 0.11],
+        Payload::try_from(json!({"city": ["Berlin", "London"]})).unwrap(),
+    ),
+    PointStruct::new(
+        3,
+        vec![0.36, 0.55, 0.47, 0.94],
+        Payload::try_from(json!({"city": ["Berlin", "Moscow"], "price": [1.99, 2.99]}))
+            .unwrap(),
+    ),
+];
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}", points).wait(true))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/typescript.md
new file mode 100644
index 000000000..641b4ec2c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-payload/typescript.md
@@ -0,0 +1,34 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: [0.05, 0.61, 0.76, 0.74],
+      payload: {
+        city: "Berlin",
+        price: 1.99,
+      },
+    },
+    {
+      id: 2,
+      vector: [0.19, 0.81, 0.75, 0.11],
+      payload: {
+        city: ["Berlin", "London"],
+        price: 1.99,
+      },
+    },
+    {
+      id: 3,
+      vector: [0.36, 0.55, 0.47, 0.94],
+      payload: {
+        city: ["Berlin", "Moscow"],
+        price: [1.99, 2.99],
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/_description.md
new file mode 100644
index 000000000..b8831498e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/_description.md
@@ -0,0 +1 @@
+This code snippet is for a PUT request to insert points into a collection, where each point has an ID, a payload containing a group ID, and a vector. The code illustrates partitioning vectors by user to ensure that each user can only access their own vectors. It emphasizes adding a `group_id` field to each vector in the collection, facilitating user-specific data access control. Additionally, it suggests using an appropriate naming convention for the key in the payload for flexibility in data structures.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/csharp.md
new file mode 100644
index 000000000..4156954a9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/csharp.md
@@ -0,0 +1,31 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new[] { 0.9f, 0.1f, 0.1f },
+			Payload = { ["group_id"] = "user_1" }
+		},
+		new()
+		{
+			Id = 2,
+			Vectors = new[] { 0.1f, 0.9f, 0.1f },
+			Payload = { ["group_id"] = "user_1" }
+		},
+		new()
+		{
+			Id = 3,
+			Vectors = new[] { 0.1f, 0.1f, 0.9f },
+			Payload = { ["group_id"] = "user_2" }
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/go.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/go.md
new file mode 100644
index 000000000..58ab4bd6b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/go.md
@@ -0,0 +1,33 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectors(0.9, 0.1, 0.1),
+			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_1"}),
+		},
+		{
+			Id:      qdrant.NewIDNum(2),
+			Vectors: qdrant.NewVectors(0.1, 0.9, 0.1),
+			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_1"}),
+		},
+		{
+			Id:      qdrant.NewIDNum(3),
+			Vectors: qdrant.NewVectors(0.1, 0.1, 0.9),
+			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_2"}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/http.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/http.md
new file mode 100644
index 000000000..bd8582286
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/http.md
@@ -0,0 +1,22 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "payload": {"group_id": "user_1"},
+            "vector": [0.9, 0.1, 0.1]
+        },
+        {
+            "id": 2,
+            "payload": {"group_id": "user_1"},
+            "vector": [0.1, 0.9, 0.1]
+        },
+        {
+            "id": 3,
+            "payload": {"group_id": "user_2"},
+            "vector": [0.1, 0.1, 0.9]
+        },
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/java.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/java.md
new file mode 100644
index 000000000..1b9c9b97d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/java.md
@@ -0,0 +1,32 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(vectors(0.9f, 0.1f, 0.1f))
+                .putAllPayload(Map.of("group_id", value("user_1")))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(2))
+                .setVectors(vectors(0.1f, 0.9f, 0.1f))
+                .putAllPayload(Map.of("group_id", value("user_1")))
+                .build(),
+            PointStruct.newBuilder()
+                .setId(id(3))
+                .setVectors(vectors(0.1f, 0.1f, 0.9f))
+                .putAllPayload(Map.of("group_id", value("user_2")))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/python.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/python.md
new file mode 100644
index 000000000..0012b0d70
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/python.md
@@ -0,0 +1,22 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            payload={"group_id": "user_1"},
+            vector=[0.9, 0.1, 0.1],
+        ),
+        models.PointStruct(
+            id=2,
+            payload={"group_id": "user_1"},
+            vector=[0.1, 0.9, 0.1],
+        ),
+        models.PointStruct(
+            id=3,
+            payload={"group_id": "user_2"},
+            vector=[0.1, 0.1, 0.9],
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/rust.md
new file mode 100644
index 000000000..b0f47cbb1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .upsert_points(UpsertPointsBuilder::new(
+        "{collection_name}",
+        vec![
+            PointStruct::new(1, vec![0.9, 0.1, 0.1], [("group_id", "user_1".into())]),
+            PointStruct::new(2, vec![0.1, 0.9, 0.1], [("group_id", "user_1".into())]),
+            PointStruct::new(3, vec![0.1, 0.1, 0.9], [("group_id", "user_2".into())]),
+        ],
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/typescript.md
new file mode 100644
index 000000000..0ecbd51c8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/insert-points/with-tenant-group-id/typescript.md
@@ -0,0 +1,25 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      payload: { group_id: "user_1" },
+      vector: [0.9, 0.1, 0.1],
+    },
+    {
+      id: 2,
+      payload: { group_id: "user_1" },
+      vector: [0.1, 0.9, 0.1],
+    },
+    {
+      id: 3,
+      payload: { group_id: "user_2" },
+      vector: [0.1, 0.1, 0.9],
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/_description.md
new file mode 100644
index 000000000..4b37aceb4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/_description.md
@@ -0,0 +1 @@
+This code snippet retrieves and lists all available collections.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/bash.md
new file mode 100644
index 000000000..343f5f58d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/bash.md
@@ -0,0 +1,3 @@
+```bash
+curl -X GET http://localhost:6333/collections
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/csharp.md
new file mode 100644
index 000000000..0be70207d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ListCollectionsAsync();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/go.md
new file mode 100644
index 000000000..5d456edf2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.ListCollections(context.Background())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/http.md
new file mode 100644
index 000000000..12f075da4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/java.md
new file mode 100644
index 000000000..1e071265c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.listCollectionsAsync().get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/python.md
new file mode 100644
index 000000000..4e77c5b29
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.get_collections()
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/rust.md
new file mode 100644
index 000000000..08d6dc107
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.list_collections().await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/typescript.md
new file mode 100644
index 000000000..dd0d49791
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/list-all-collections/simple/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.getCollections();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/_description.md
new file mode 100644
index 000000000..fbf91269f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/_description.md
@@ -0,0 +1 @@
+This code snippet represents a functionality to overwrite the payload for specified points within a collection. It allows you to replace the current payload of the specified points with a new set of properties and values provided in the request body. The points that will have their payloads overwritten are identified by their respective IDs within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/csharp.md
new file mode 100644
index 000000000..b86654fa8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.OverwritePayloadAsync(
+    collectionName: "{collection_name}",
+    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
+    ids: new ulong[] { 0, 3, 10 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/go.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/go.md
new file mode 100644
index 000000000..d6c1ca371
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.OverwritePayload(context.Background(), &qdrant.SetPayloadPoints{
+    CollectionName: "{collection_name}",
+    Payload: qdrant.NewValueMap(
+        map[string]any{"property1": "string", "property2": "string"}),
+    PointsSelector: qdrant.NewPointsSelector(
+        qdrant.NewIDNum(0),
+        qdrant.NewIDNum(3)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/http.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/http.md
new file mode 100644
index 000000000..a5ab9b12b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/http.md
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}/points/payload
+{
+    "payload": {
+        "property1": "string",
+        "property2": "string"
+    },
+    "points": [
+        0, 3, 100
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/java.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/java.md
new file mode 100644
index 000000000..4986064ab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/java.md
@@ -0,0 +1,16 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+
+client
+    .overwritePayloadAsync(
+        "{collection_name}",
+        Map.of("property1", value("string"), "property2", value("string")),
+        List.of(id(0), id(3), id(10)),
+        true,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/python.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/python.md
new file mode 100644
index 000000000..4833423e1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/python.md
@@ -0,0 +1,10 @@
+```python
+client.overwrite_payload(
+    collection_name="{collection_name}",
+    payload={
+        "property1": "string",
+        "property2": "string",
+    },
+    points=[0, 3, 10],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/rust.md
new file mode 100644
index 000000000..e2347b8e2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{PointsIdsList, SetPayloadPointsBuilder};
+use qdrant_client::Payload;
+use serde_json::json;
+
+client
+    .overwrite_payload(
+        SetPayloadPointsBuilder::new(
+            "{collection_name}",
+            Payload::try_from(json!({
+                "property1": "string",
+                "property2": "string",
+            }))
+            .unwrap(),
+        )
+        .points_selector(PointsIdsList {
+            ids: vec![0.into(), 3.into(), 10.into()],
+        })
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/typescript.md
new file mode 100644
index 000000000..b64990279
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/overwrite-payload/by-point-id/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.overwritePayload("{collection_name}", {
+  payload: {
+    property1: "string",
+    property2: "string",
+  },
+  points: [0, 3, 10],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/_description.md
new file mode 100644
index 000000000..ef67c6c31
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a request to retrieve groups of data points based on specified grouping parameters. The query specifies the field to group by, the maximum number of groups to return, and the maximum number of points allowed per group.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/csharp.md
new file mode 100644
index 000000000..d1376e140
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryGroupsAsync(
+    collectionName: "{collection_name}",
+    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+    groupBy: "document_id",
+    limit: 4,
+    groupSize: 2
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/go.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/go.md
new file mode 100644
index 000000000..a6818240e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	GroupBy:        "document_id",
+	GroupSize:      qdrant.PtrOf(uint64(2)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/http.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/http.md
new file mode 100644
index 000000000..e450ade2c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/query/groups
+{
+    // Same as in the regular query API
+    "query": [1.1],
+    // Grouping parameters
+    "group_by": "document_id",  // Path of the field to group by
+    "limit": 4,                 // Max amount of groups
+    "group_size": 2            // Max amount of points per group
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/java.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/java.md
new file mode 100644
index 000000000..450b0b27f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/java.md
@@ -0,0 +1,15 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.grpc.Points.SearchPointGroups;
+
+client.queryGroupsAsync(
+        QueryPointGroups.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setGroupBy("document_id")
+                .setLimit(4)
+                .setGroupSize(2)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/python.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/python.md
new file mode 100644
index 000000000..783322d96
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/python.md
@@ -0,0 +1,11 @@
+```python
+client.query_points_groups(
+    collection_name="{collection_name}",
+    # Same as in the regular query_points() API
+    query=[1.1],
+    # Grouping parameters
+    group_by="document_id",  # Path of the field to group by
+    limit=4,  # Max amount of groups
+    group_size=2,  # Max amount of points per group
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/rust.md
new file mode 100644
index 000000000..833adf9d5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/rust.md
@@ -0,0 +1,14 @@
+```rust
+use qdrant_client::qdrant::QueryPointGroupsBuilder;
+
+client
+    .query_groups(
+        QueryPointGroupsBuilder::new("{collection_name}", "document_id")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .group_size(2u64)
+            .with_payload(true)
+            .with_vectors(true)
+            .limit(4u64),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/typescript.md
new file mode 100644
index 000000000..b75973016
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/basic/typescript.md
@@ -0,0 +1,8 @@
+```typescript
+client.queryGroups("{collection_name}", {
+    query: [1.1],
+    group_by: "document_id",
+    limit: 4,
+    group_size: 2,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/_description.md
new file mode 100644
index 000000000..2179cc5be
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to use the feature for looking up information from another collection while grouping data. By utilizing the `with_lookup` parameter in the request payload, you can efficiently retrieve shared information associated with points grouped by a specific identifier. This approach helps in reducing redundancy and optimizing storage space, especially when dealing with large payloads across multiple grouped points. The `with_lookup` parameter allows you to specify what data to bring from the related points in the lookup collection, such as titles and text, providing a consolidated view of information within each group.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/csharp.md
new file mode 100644
index 000000000..aecbd6d1d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/csharp.md
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.SearchGroupsAsync(
+    collectionName: "{collection_name}",
+    vector: new float[] { 0.2f, 0.1f, 0.9f, 0.7f},
+    groupBy: "document_id",
+    limit: 2,
+    groupSize: 2,
+    withLookup: new WithLookup
+    {
+        Collection = "documents",
+        WithPayload = new WithPayloadSelector
+        {
+            Include = new PayloadIncludeSelector { Fields = { new string[] { "title", "text" } } }
+        },
+        WithVectors = false
+    }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/go.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/go.md
new file mode 100644
index 000000000..d5ad9f7b6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	GroupBy:        "document_id",
+	GroupSize:      qdrant.PtrOf(uint64(2)),
+	WithLookup: &qdrant.WithLookup{
+		Collection:  "documents",
+		WithPayload: qdrant.NewWithPayloadInclude("title", "text"),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/http.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/http.md
new file mode 100644
index 000000000..bbd4d3fd4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/http.md
@@ -0,0 +1,26 @@
+```http
+POST /collections/chunks/points/query/groups
+{
+    // Same as in the regular query API
+    "query": [1.1],
+
+    // Grouping parameters
+    "group_by": "document_id",
+    "limit": 2,
+    "group_size": 2,
+
+    // Lookup parameters
+    "with_lookup": {
+        // Name of the collection to look up points in
+        "collection": "documents",
+
+        // Options for specifying what to bring from the payload 
+        // of the looked up point, true by default
+        "with_payload": ["title", "text"],
+
+        // Options for specifying what to bring from the vector(s) 
+        // of the looked up point, true by default
+        "with_vectors": false
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/java.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/java.md
new file mode 100644
index 000000000..bd25c00d1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/java.md
@@ -0,0 +1,26 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.grpc.Points.QueryPointGroups;
+import io.qdrant.client.grpc.Points.WithLookup;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.WithVectorsSelectorFactory.enable;
+import static io.qdrant.client.WithPayloadSelectorFactory.include;
+
+client.queryGroupsAsync(
+        QueryPointGroups.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setGroupBy("document_id")
+                .setLimit(2)
+                .setGroupSize(2)
+                .setWithLookup(
+                        WithLookup.newBuilder()
+                                .setCollection("documents")
+                                .setWithPayload(include(List.of("title", "text")))
+                                .setWithVectors(enable(false))
+                                .build())
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/python.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/python.md
new file mode 100644
index 000000000..01314e4e3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/python.md
@@ -0,0 +1,22 @@
+```python
+client.query_points_groups(
+    collection_name="chunks",
+    # Same as in the regular search() API
+    query=[1.1],
+    # Grouping parameters
+    group_by="document_id",  # Path of the field to group by
+    limit=2,  # Max amount of groups
+    group_size=2,  # Max amount of points per group
+    # Lookup parameters
+    with_lookup=models.WithLookup(
+        # Name of the collection to look up points in
+        collection="documents",
+        # Options for specifying what to bring from the payload
+        # of the looked up point, True by default
+        with_payload=["title", "text"],
+        # Options for specifying what to bring from the vector(s)
+        # of the looked up point, True by default
+        with_vectors=False,
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/rust.md
new file mode 100644
index 000000000..c56f63545
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/rust.md
@@ -0,0 +1,19 @@
+```rust
+use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointGroupsBuilder, WithLookupBuilder};
+
+client
+    .query_groups(
+        QueryPointGroupsBuilder::new("{collection_name}", "document_id")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(2u64)
+            .limit(2u64)
+            .with_lookup(
+                WithLookupBuilder::new("documents")
+                    .with_payload(SelectorOptions::Include(
+                        vec!["title".to_string(), "text".to_string()].into(),
+                    ))
+                    .with_vectors(false),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/typescript.md
new file mode 100644
index 000000000..e9aaa4507
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-groups/with-lookup/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+client.queryGroups("{collection_name}", {
+    query: [1.1],
+    group_by: "document_id",
+    limit: 2,
+    group_size: 2,
+    with_lookup: {
+        collection: "documents",
+        with_payload: ["title", "text"],
+        with_vectors: false,
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/_description.md
new file mode 100644
index 000000000..dbbd691cd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the usage of a recommendation API in a system called Qdrant. It shows how to make a POST request to search for points based on multiple positive and negative examples, using point IDs or raw vectors. The search query includes a strategy for recommendation and a filtering condition to find points in a specific city, like London.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/csharp.md
new file mode 100644
index 000000000..156753a5c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/csharp.md
@@ -0,0 +1,17 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new RecommendInput {
+        Positive = { 100, 231 },
+        Negative = { 718 }
+    },
+    filter: MatchKeyword("city", "London"),
+    limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/go.md
new file mode 100644
index 000000000..7741c9ce3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/go.md
@@ -0,0 +1,30 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+    CollectionName: "{collection_name}",
+    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
+        Positive: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
+        },
+        Negative: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+        },
+    }),
+    Filter: &qdrant.Filter{
+        Must: []*qdrant.Condition{
+            qdrant.NewMatch("city", "London"),
+        },
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/http.md
new file mode 100644
index 000000000..c5e698d2e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/http.md
@@ -0,0 +1,22 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "recommend": {
+      "positive": [100, 231],
+      "negative": [718, [0.2, 0.3, 0.4, 0.5]],
+      "strategy": "average_vector"
+    }
+  },
+  "filter": {
+    "must": [
+      {
+        "key": "city",
+        "match": {
+          "value": "London"
+        }
+      }
+    ]
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/java.md
new file mode 100644
index 000000000..c2a1b80b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/java.md
@@ -0,0 +1,28 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.RecommendInput;
+import io.qdrant.client.grpc.Points.RecommendStrategy;
+import io.qdrant.client.grpc.Points.Filter;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.recommend;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(recommend(RecommendInput.newBuilder()
+                .addAllPositive(List.of(vectorInput(100), vectorInput(200), vectorInput(100.0f, 231.0f)))
+                .addAllNegative(List.of(vectorInput(718), vectorInput(0.2f, 0.3f, 0.4f, 0.5f)))
+                .setStrategy(RecommendStrategy.AverageVector)
+                .build()))
+        .setFilter(Filter.newBuilder().addMust(matchKeyword("city", "London")))
+        .setLimit(3)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/python.md
new file mode 100644
index 000000000..67d1595f5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/python.md
@@ -0,0 +1,27 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.RecommendQuery(
+        recommend=models.RecommendInput(
+            positive=[100, 231],
+            negative=[718, [0.2, 0.3, 0.4, 0.5]],
+            strategy=models.RecommendStrategy.AVERAGE_VECTOR,
+        )
+    ),
+    query_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="city",
+                match=models.MatchValue(
+                    value="London",
+                ),
+            )
+        ]
+    ),
+    limit=3,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/rust.md
new file mode 100644
index 000000000..6ef56990a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/rust.md
@@ -0,0 +1,28 @@
+```rust
+use qdrant_client::qdrant::{
+    Condition, Filter, QueryPointsBuilder, RecommendInputBuilder, RecommendStrategy,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+    
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(
+                RecommendInputBuilder::default()
+                    .add_positive(100)
+                    .add_positive(231)
+                    .add_positive(vec![0.2, 0.3, 0.4, 0.5])
+                    .add_negative(718)
+                    .strategy(RecommendStrategy::AverageVector)
+                    .build(),
+            )
+            .limit(3)
+            .filter(Filter::must([Condition::matches(
+                "city",
+                "London".to_string(),
+            )])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/typescript.md
new file mode 100644
index 000000000..f0fa87a71
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/basic-recommend/typescript.md
@@ -0,0 +1,26 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: {
+        recommend: {
+            positive: [100, 231],
+            negative: [718, [0.2, 0.3, 0.4, 0.5]],
+            strategy: "average_vector"
+        }
+    },
+    filter: {
+        must: [
+            {
+                key: "city",
+                match: {
+                    value: "London",
+                },
+            },
+        ],
+    },
+    limit: 3
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/_description.md
new file mode 100644
index 000000000..e91c3e265
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a context-based approach for performing a search operation on a collection of points. The search involves specifying positive and negative context points along with a limit on the number of results to be returned. By using a context score derived from the triplet-loss concept, the search is guided towards areas with fewer negative examples. This method allows for a more diverse and constrained result set, rather than only focusing on a single point. The approach can be utilized not just for general searching but also for recommendation systems by adapting it to specific use cases.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/csharp.md
new file mode 100644
index 000000000..73babfb14
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/csharp.md
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  query: new ContextInput {
+    Pairs = {
+      new ContextInputPair {
+        Positive = 100,
+          Negative = 718
+      },
+      new ContextInputPair {
+        Positive = 200,
+          Negative = 300
+      },
+    }
+  },
+  limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/go.md
new file mode 100644
index 000000000..371eb2ceb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/go.md
@@ -0,0 +1,28 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+    CollectionName: "{collection_name}",
+    Query: qdrant.NewQueryContext(&qdrant.ContextInput{
+        Pairs: []*qdrant.ContextInputPair{
+            {
+                Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+                Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+            },
+            {
+                Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
+                Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
+            },
+        },
+    }),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/http.md
new file mode 100644
index 000000000..a61404046
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/http.md
@@ -0,0 +1,18 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "context": [
+      {
+        "positive": 100,
+        "negative": 718
+      },
+      {
+        "positive": 200,
+        "negative": 300
+      }
+    ]
+  },
+  "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/java.md
new file mode 100644
index 000000000..a5ef878ba
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/java.md
@@ -0,0 +1,31 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.ContextInput;
+import io.qdrant.client.grpc.Points.ContextInputPair;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.context;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(context(ContextInput.newBuilder()
+                .addAllPairs(List.of(
+                        ContextInputPair.newBuilder()
+                                .setPositive(vectorInput(100))
+                                .setNegative(vectorInput(718))
+                                .build(),
+                        ContextInputPair.newBuilder()
+                                .setPositive(vectorInput(200))
+                                .setNegative(vectorInput(300))
+                                .build()))
+                .build()))
+        .setLimit(10)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/python.md
new file mode 100644
index 000000000..d549ac627
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/python.md
@@ -0,0 +1,27 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+discover_queries = [
+    models.QueryRequest(
+        query=models.ContextQuery(
+            context=[
+                models.ContextPair(
+                    positive=100,
+                    negative=718,
+                ),
+                models.ContextPair(
+                    positive=200,
+                    negative=300,
+                ),
+            ],
+        ),
+        limit=10,
+    ),
+]
+
+client.query_batch_points(
+    collection_name="{collection_name}", requests=discover_queries
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/rust.md
new file mode 100644
index 000000000..5f4cbcd87
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{ContextInputBuilder, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}").query(
+            ContextInputBuilder::default()
+                .add_pair(100, 718)
+                .add_pair(200, 300)
+                .build(),
+        ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/typescript.md
new file mode 100644
index 000000000..e5b418004
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/context-basic/typescript.md
@@ -0,0 +1,21 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: {
+        context: [
+            {
+                positive: 100,
+                negative: 718,
+            },
+            {
+                positive: 200,
+                negative: 300,
+            },
+        ]
+    },
+    limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/_description.md
new file mode 100644
index 000000000..2e0ec57f1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a discovery search functionality for querying points within a specific collection. The search query includes a target vector and contextual positive and negative examples. The search is constrained to a vector space for performing the search operation. The provided code showcases a POST request to query points based on specified parameters such as target vector values, positive and negative examples within the context, and a limit on the number of results to be returned.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/csharp.md
new file mode 100644
index 000000000..330d0123d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/csharp.md
@@ -0,0 +1,26 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new DiscoverInput {
+        Target = new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+        Context = new ContextInput {
+            Pairs = {
+                new ContextInputPair {
+                    Positive = 100,
+                    Negative = 718
+                },
+                new ContextInputPair {
+                    Positive = 200,
+                    Negative = 300
+                },
+            }   
+        },
+    },
+    limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/go.md
new file mode 100644
index 000000000..711729a39
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/go.md
@@ -0,0 +1,31 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+    CollectionName: "{collection_name}",
+    Query: qdrant.NewQueryDiscover(&qdrant.DiscoverInput{
+        Target: qdrant.NewVectorInput(0.2, 0.1, 0.9, 0.7),
+        Context: &qdrant.ContextInput{
+            Pairs: []*qdrant.ContextInputPair{
+                {
+                    Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+                    Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+                },
+                {
+                    Positive: qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
+                    Negative: qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
+                },
+            },
+        },
+    }),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/http.md
new file mode 100644
index 000000000..e2778bac0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/http.md
@@ -0,0 +1,21 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "discover": {
+      "target": [0.2, 0.1, 0.9, 0.7],
+      "context": [
+        {
+          "positive": 100,
+          "negative": 718
+        },
+        {
+          "positive": 200,
+          "negative": 300
+        }
+      ]
+    }
+  },
+  "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/java.md
new file mode 100644
index 000000000..86f167f09
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/java.md
@@ -0,0 +1,35 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.ContextInput;
+import io.qdrant.client.grpc.Points.ContextInputPair;
+import io.qdrant.client.grpc.Points.DiscoverInput;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.discover;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(discover(DiscoverInput.newBuilder()
+                .setTarget(vectorInput(0.2f, 0.1f, 0.9f, 0.7f))
+                .setContext(ContextInput.newBuilder()
+                        .addAllPairs(List.of(
+                                ContextInputPair.newBuilder()
+                                        .setPositive(vectorInput(100))
+                                        .setNegative(vectorInput(718))
+                                        .build(),
+                                ContextInputPair.newBuilder()
+                                        .setPositive(vectorInput(200))
+                                        .setNegative(vectorInput(300))
+                                        .build()))
+                        .build())
+                .build()))
+        .setLimit(10)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/python.md
new file mode 100644
index 000000000..9361fa6bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/python.md
@@ -0,0 +1,30 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+discover_queries = [
+    models.QueryRequest(
+        query=models.DiscoverQuery(
+            discover=models.DiscoverInput(
+                target=[0.2, 0.1, 0.9, 0.7],
+                context=[
+                    models.ContextPair(
+                        positive=100,
+                        negative=718,
+                    ),
+                    models.ContextPair(
+                        positive=200,
+                        negative=300,
+                    ),
+                ],
+            )
+        ),
+        limit=10,
+    ),
+]
+
+client.query_batch_points(
+    collection_name="{collection_name}", requests=discover_queries
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/rust.md
new file mode 100644
index 000000000..2986c8c2e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{ContextInputBuilder, DiscoverInputBuilder, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}").query(
+            DiscoverInputBuilder::new(
+                vec![0.2, 0.1, 0.9, 0.7],
+                ContextInputBuilder::default()
+                    .add_pair(100, 718)
+                    .add_pair(200, 300),
+            )
+            .build(),
+        ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/typescript.md
new file mode 100644
index 000000000..668d63973
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/discovery-basic/typescript.md
@@ -0,0 +1,24 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: {
+        discover: {
+            target: [0.2, 0.1, 0.9, 0.7],
+            context: [
+                {
+                    positive: 100,
+                    negative: 718,
+                },
+                {
+                    positive: 200,
+                    negative: 300,
+                },
+            ],
+        }
+    },
+    limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/_description.md
new file mode 100644
index 000000000..570726b8a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a batch recommendation API that allows for multiple recommendation requests to be grouped together. Each request contains a query for positive and negative items, along with a filter to narrow down the results. The API is designed to handle multiple recommendation requests efficiently, similar to the batch search API, offering convenience and scalability.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/csharp.md
new file mode 100644
index 000000000..366bc93a1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/csharp.md
@@ -0,0 +1,36 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+var filter = MatchKeyword("city", "london");
+
+await client.QueryBatchAsync(
+    collectionName: "{collection_name}",
+    queries:
+    [
+        new QueryPoints()
+        {
+            CollectionName = "{collection_name}",
+            Query = new RecommendInput {
+                Positive = { 100, 231 },
+                Negative = { 718 },
+            },
+            Limit = 3,
+            Filter = filter,
+        },
+                new QueryPoints()
+        {
+            CollectionName = "{collection_name}",
+            Query = new RecommendInput {
+                Positive = { 200, 67 },
+                Negative = { 300 },
+            },
+            Limit = 3,
+            Filter = filter,
+        }
+    ]
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/go.md
new file mode 100644
index 000000000..402540536
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/go.md
@@ -0,0 +1,52 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+filter := qdrant.Filter{
+    Must: []*qdrant.Condition{
+        qdrant.NewMatch("city", "London"),
+    },
+}
+client.QueryBatch(context.Background(), &qdrant.QueryBatchPoints{
+    CollectionName: "{collection_name}",
+    QueryPoints: []*qdrant.QueryPoints{
+        {
+            CollectionName: "{collection_name}",
+            Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
+                Positive: []*qdrant.VectorInput{
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
+                },
+                Negative: []*qdrant.VectorInput{
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+                },
+            },
+            ),
+            Filter: &filter,
+        },
+        {
+            CollectionName: "{collection_name}",
+            Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
+                Positive: []*qdrant.VectorInput{
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(200)),
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(67)),
+                },
+                Negative: []*qdrant.VectorInput{
+                    qdrant.NewVectorInputID(qdrant.NewIDNum(300)),
+                },
+            },
+            ),
+            Filter: &filter,
+        },
+    },
+},
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/http.md
new file mode 100644
index 000000000..2e4de98f7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/http.md
@@ -0,0 +1,45 @@
+```http
+POST /collections/{collection_name}/query/batch
+{
+  "searches": [
+    {
+      "query": {
+        "recommend": {
+          "positive": [100, 231],
+          "negative": [718]
+        }
+      },
+      "filter": {
+        "must": [
+          {
+            "key": "city",
+            "match": {
+              "value": "London"
+            }
+          }
+        ]
+      },
+      "limit": 10
+    },
+    {
+      "query": {
+        "recommend": {
+          "positive": [200, 67],
+          "negative": [300]
+        }
+      },
+      "filter": {
+        "must": [
+          {
+            "key": "city",
+            "match": {
+              "value": "London"
+            }
+          }
+        ]
+      },
+      "limit": 10
+    }
+  ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/java.md
new file mode 100644
index 000000000..8221db4e8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/java.md
@@ -0,0 +1,42 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.RecommendInput;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.recommend;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+Filter filter = Filter.newBuilder().addMust(matchKeyword("city", "London")).build();
+
+List<QueryPoints> recommendQueries = List.of(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(recommend(
+                        RecommendInput.newBuilder()
+                                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
+                                .addAllNegative(List.of(vectorInput(731)))
+                                .build()))
+                .setFilter(filter)
+                .setLimit(3)
+                .build(),
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(recommend(
+                        RecommendInput.newBuilder()
+                                .addAllPositive(List.of(vectorInput(200), vectorInput(67)))
+                                .addAllNegative(List.of(vectorInput(300)))
+                                .build()))
+                .setFilter(filter)
+                .setLimit(3)
+                .build());
+                
+client.queryBatchAsync("{collection_name}", recommendQueries).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/python.md
new file mode 100644
index 000000000..cb4fe96f5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/python.md
@@ -0,0 +1,37 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+filter_ = models.Filter(
+    must=[
+        models.FieldCondition(
+            key="city",
+            match=models.MatchValue(
+                value="London",
+            ),
+        )
+    ]
+)
+
+recommend_queries = [
+    models.QueryRequest(
+        query=models.RecommendQuery(
+            recommend=models.RecommendInput(positive=[100, 231], negative=[718])
+        ),
+        filter=filter_,
+        limit=3,
+    ),
+    models.QueryRequest(
+        query=models.RecommendQuery(
+            recommend=models.RecommendInput(positive=[200, 67], negative=[300])
+        ),
+        filter=filter_,
+        limit=3,
+    ),
+]
+
+client.query_batch_points(
+    collection_name="{collection_name}", requests=recommend_queries
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/rust.md
new file mode 100644
index 000000000..29cc46c91
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/rust.md
@@ -0,0 +1,41 @@
+```rust
+use qdrant_client::qdrant::{
+    Condition, Filter, QueryBatchPointsBuilder, QueryPointsBuilder,
+    RecommendInputBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let filter = Filter::must([Condition::matches("city", "London".to_string())]);
+
+let recommend_queries = vec![
+    QueryPointsBuilder::new("{collection_name}")
+        .query(
+            RecommendInputBuilder::default()
+                .add_positive(100)
+                .add_positive(231)
+                .add_negative(718)
+                .build(),
+        )
+        .filter(filter.clone())
+        .build(),
+    QueryPointsBuilder::new("{collection_name}")
+        .query(
+            RecommendInputBuilder::default()
+                .add_positive(200)
+                .add_positive(67)
+                .add_negative(300)
+                .build(),
+        )
+        .filter(filter)
+        .build(),
+];
+
+client
+    .query_batch(QueryBatchPointsBuilder::new(
+        "{collection_name}",
+        recommend_queries,
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/typescript.md
new file mode 100644
index 000000000..50df4092f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-batch/typescript.md
@@ -0,0 +1,43 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+const filter = {
+    must: [
+        {
+            key: "city",
+            match: {
+                value: "London",
+            },
+        },
+    ],
+};
+
+const searches = [
+    {
+        query: {
+            recommend: {
+                positive: [100, 231],
+                negative: [718]
+            }
+        },
+        filter,
+        limit: 3,
+    },
+    {
+        query: {
+            recommend: {
+                positive: [200, 67],
+                negative: [300]
+            }
+        },
+        filter,
+        limit: 3,
+    },
+];
+
+client.queryBatch("{collection_name}", {
+    searches,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/_description.md
new file mode 100644
index 000000000..f7332a885
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to utilize the `lookup_from` parameter when querying points. By specifying an external collection and vector name to lookup from, you can retrieve recommendations based on vectors from a different collection. This feature is beneficial when dealing with item-to-user recommendation scenarios, where vectors with the same parameters are stored in separate collections.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/csharp.md
new file mode 100644
index 000000000..43352ab71
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/csharp.md
@@ -0,0 +1,21 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new RecommendInput {
+        Positive = { 100, 231 },
+        Negative = { 718 }
+    },
+    usingVector: "image",
+    limit: 10,
+    lookupFrom: new LookupLocation
+    {
+        CollectionName = "{external_collection_name}",
+        VectorName = "{external_vector_name}",
+    }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/go.md
new file mode 100644
index 000000000..a65c976a3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/go.md
@@ -0,0 +1,30 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+    CollectionName: "{collection_name}",
+    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
+        Positive: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
+        },
+        Negative: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+        },
+    }),
+    Using: qdrant.PtrOf("image"),
+    LookupFrom: &qdrant.LookupLocation{
+        CollectionName: "{external_collection_name}",
+        VectorName:     qdrant.PtrOf("{external_vector_name}"),
+    },
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/http.md
new file mode 100644
index 000000000..d51f3397d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/http.md
@@ -0,0 +1,16 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "recommend": {
+      "positive": [100, 231],
+      "negative": [718]
+    }
+  },
+  "limit": 10,
+  "lookup_from": {
+    "collection": "{external_collection_name}",
+    "vector": "{external_vector_name}"
+  }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/java.md
new file mode 100644
index 000000000..b57b9d480
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/java.md
@@ -0,0 +1,25 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.grpc.Points.LookupLocation;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.RecommendInput;
+
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.recommend;
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(recommend(RecommendInput.newBuilder()
+                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
+                .addAllNegative(List.of(vectorInput(718)))
+                .build()))
+        .setUsing("image")
+        .setLimit(10)
+        .setLookupFrom(
+                LookupLocation.newBuilder()
+                        .setCollectionName("{external_collection_name}")
+                        .setVectorName("{external_vector_name}")
+                        .build())
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/python.md
new file mode 100644
index 000000000..a5acc4395
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/python.md
@@ -0,0 +1,16 @@
+```python
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.RecommendQuery(
+        recommend=models.RecommendInput(
+            positive=[100, 231],
+            negative=[718],
+        )
+    ),
+    using="image",
+    limit=10,
+    lookup_from=models.LookupLocation(
+        collection="{external_collection_name}", vector="{external_vector_name}"
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/rust.md
new file mode 100644
index 000000000..d905e297d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/rust.md
@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::qdrant::{LookupLocationBuilder, QueryPointsBuilder, RecommendInputBuilder};
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(
+                RecommendInputBuilder::default()
+                    .add_positive(100)
+                    .add_positive(231)
+                    .add_negative(718)
+                    .build(),
+            )
+            .limit(10)
+            .using("image")
+            .lookup_from(
+                LookupLocationBuilder::new("{external_collection_name}")
+                    .vector_name("{external_vector_name}"),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/typescript.md
new file mode 100644
index 000000000..08106d46b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-lookup-from/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+client.query("{collection_name}", {
+    query: {
+        recommend: {
+            positive: [100, 231],
+            negative: [718],
+        }
+    },
+    using: "image",
+    limit: 10,
+    lookup_from: {
+        collection: "{external_collection_name}",
+        vector: "{external_vector_name}"
+    }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/_description.md
new file mode 100644
index 000000000..6d85cf6c9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/_description.md
@@ -0,0 +1 @@
+The code snippet demonstrates how to make a query to explore points in a collection based on named vectors. In this case, the query is configured to recommend vectors specified as 'positive' and 'negative'. By setting the 'using' parameter to "image" and limiting the results to 10, you can retrieve relevant data for the specified vectors in the collection. This feature is available starting from version 0.10.0 and allows for more granular recommendation requests when dealing with multiple vectors in a collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/csharp.md
new file mode 100644
index 000000000..a8ba38e56
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new RecommendInput {
+        Positive = { 100, 231 },
+        Negative = { 718 }
+    },
+    usingVector: "image",
+    limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/go.md
new file mode 100644
index 000000000..a179f94bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+    CollectionName: "{collection_name}",
+    Query: qdrant.NewQueryRecommend(&qdrant.RecommendInput{
+        Positive: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(100)),
+            qdrant.NewVectorInputID(qdrant.NewIDNum(231)),
+        },
+        Negative: []*qdrant.VectorInput{
+            qdrant.NewVectorInputID(qdrant.NewIDNum(718)),
+        },
+    }),
+    Using: qdrant.PtrOf("image"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/http.md
new file mode 100644
index 000000000..dc7917224
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "recommend": {
+      "positive": [100, 231],
+      "negative": [718]
+    }
+  },
+  "using": "image",
+  "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/java.md
new file mode 100644
index 000000000..3432063c7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/java.md
@@ -0,0 +1,19 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.RecommendInput;
+
+import static io.qdrant.client.VectorInputFactory.vectorInput;
+import static io.qdrant.client.QueryFactory.recommend;
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(recommend(RecommendInput.newBuilder()
+                .addAllPositive(List.of(vectorInput(100), vectorInput(231)))
+                .addAllNegative(List.of(vectorInput(718)))
+                .build()))
+        .setUsing("image")
+        .setLimit(10)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/python.md
new file mode 100644
index 000000000..54473696d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/python.md
@@ -0,0 +1,13 @@
+```python
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.RecommendQuery(
+        recommend=models.RecommendInput(
+            positive=[100, 231],
+            negative=[718],
+        )
+    ),
+    using="image",
+    limit=10,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/rust.md
new file mode 100644
index 000000000..350efe3ae
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{QueryPointsBuilder, RecommendInputBuilder};
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(
+                RecommendInputBuilder::default()
+                    .add_positive(100)
+                    .add_positive(231)
+                    .add_negative(718)
+                    .build(),
+            )
+            .limit(10)
+            .using("image"),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/typescript.md
new file mode 100644
index 000000000..c7ed78d46
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points-explore/recommend-named-vectors/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+client.query("{collection_name}", {
+    query: {
+        recommend: {
+            positive: [100, 231],
+            negative: [718],
+        }
+    },
+    using: "image",
+    limit: 10
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/_description.md
new file mode 100644
index 000000000..c2e956436
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/_description.md
@@ -0,0 +1 @@
+This code snippet represents a search query that specifies certain filtering criteria and parameters to query points within a collection. The query is targeting points based on specified coordinates, with a filter applied to only include points where the 'city' key matches the value 'London'. Additionally, parameters such as 'hnsw_ef' and 'exact' are set to optimize the search. The search is requested to return a maximum of 3 matching results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/csharp.md
new file mode 100644
index 000000000..536f6873c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+    filter: MatchKeyword("city", "London"),
+    searchParams: new SearchParams { Exact = false, HnswEf = 128 },
+    limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/go.md
new file mode 100644
index 000000000..eda6436c1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("city", "London"),
+		},
+	},
+	Params: &qdrant.SearchParams{
+		Exact:  qdrant.PtrOf(false),
+		HnswEf: qdrant.PtrOf(uint64(128)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/http.md
new file mode 100644
index 000000000..cda3a1236
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/http.md
@@ -0,0 +1,21 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.79],
+    "filter": {
+        "must": [
+            {
+                "key": "city",
+                "match": {
+                    "value": "London"
+                }
+            }
+        ]
+    },
+    "params": {
+        "hnsw_ef": 128,
+        "exact": false
+    },
+    "limit": 3
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/java.md
new file mode 100644
index 000000000..a464cb253
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/java.md
@@ -0,0 +1,23 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+        .setFilter(Filter.newBuilder().addMust(matchKeyword("city", "London")).build())
+        .setParams(SearchParams.newBuilder().setExact(false).setHnswEf(128).build())
+        .setLimit(3)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/python.md
new file mode 100644
index 000000000..a01e24c2f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/python.md
@@ -0,0 +1,22 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    query_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="city",
+                match=models.MatchValue(
+                    value="London",
+                ),
+            )
+        ]
+    ),
+    search_params=models.SearchParams(hnsw_ef=128, exact=False),
+    limit=3,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/rust.md
new file mode 100644
index 000000000..efa6315ba
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, QueryPointsBuilder, SearchParamsBuilder};
+use qdrant_client::Qdrant;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .filter(Filter::must([Condition::matches(
+                "city",
+                "London".to_string(),
+            )]))
+            .params(SearchParamsBuilder::default().hnsw_ef(128).exact(false)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/typescript.md
new file mode 100644
index 000000000..12739cf59
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/basic-with-filter-and-params/typescript.md
@@ -0,0 +1,24 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    filter: {
+        must: [
+            {
+                key: "city",
+                match: {
+                    value: "London",
+                },
+            },
+        ],
+    },
+    params: {
+        hnsw_ef: 128,
+        exact: false,
+    },
+    limit: 3,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/_description.md
new file mode 100644
index 000000000..adc5b11fb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the batch search feature of a system. The batch search API allows you to send multiple search queries in a single request. Each search query includes a set of criteria to filter results and a limit on the number of expected results. By batching search requests together, the system can optimize processing by sharing intermediary results when queries have the same filters. This approach helps reduce network connections and improve overall efficiency, especially for complex filters. To use the batch search API, package your search requests together with the desired criteria.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/csharp.md
new file mode 100644
index 000000000..9812412bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/csharp.md
@@ -0,0 +1,29 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+var filter = MatchKeyword("city", "London");
+
+var queries = new List<QueryPoints>
+{
+    new()
+    {
+        CollectionName = "{collection_name}",
+        Query = new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+        Filter = filter,
+        Limit = 3
+    },
+    new()
+    {
+        CollectionName = "{collection_name}",
+        Query = new float[] { 0.5f, 0.3f, 0.2f, 0.3f },
+        Filter = filter,
+        Limit = 3
+    }
+};
+
+await client.QueryBatchAsync(collectionName: "{collection_name}", queries: queries);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/go.md
new file mode 100644
index 000000000..1e0a79156
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/go.md
@@ -0,0 +1,34 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+filter := qdrant.Filter{
+	Must: []*qdrant.Condition{
+		qdrant.NewMatch("city", "London"),
+	},
+}
+
+client.QueryBatch(context.Background(), &qdrant.QueryBatchPoints{
+	CollectionName: "{collection_name}",
+	QueryPoints: []*qdrant.QueryPoints{
+		{
+			CollectionName: "{collection_name}",
+			Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+			Filter:         &filter,
+		},
+		{
+			CollectionName: "{collection_name}",
+			Query:          qdrant.NewQuery(0.5, 0.3, 0.2, 0.3),
+			Filter:         &filter,
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/http.md
new file mode 100644
index 000000000..961876611
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/http.md
@@ -0,0 +1,35 @@
+```http
+POST /collections/{collection_name}/points/query/batch
+{
+    "searches": [
+        {
+            "query": [0.2, 0.1, 0.9, 0.7],
+            "filter": {
+                "must": [
+                    {
+                        "key": "city",
+                        "match": {
+                            "value": "London"
+                        }
+                    }
+                ]
+            },
+            "limit": 3
+        },
+        {
+            "query": [0.5, 0.3, 0.2, 0.3],
+            "filter": {
+                "must": [
+                    {
+                        "key": "city",
+                        "match": {
+                            "value": "London"
+                        }
+                    }
+                ]
+            },
+            "limit": 3
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/java.md
new file mode 100644
index 000000000..a8e1ca7b9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/java.md
@@ -0,0 +1,30 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+Filter filter = Filter.newBuilder().addMust(matchKeyword("city", "London")).build();
+
+List<QueryPoints> searches = List.of(
+        QueryPoints.newBuilder()
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setFilter(filter)
+                .setLimit(3)
+                .build(),
+        QueryPoints.newBuilder()
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setFilter(filter)
+                .setLimit(3)
+                .build());
+
+client.queryBatchAsync("{collection_name}", searches).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/python.md
new file mode 100644
index 000000000..d72ef8157
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/python.md
@@ -0,0 +1,23 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+filter_ = models.Filter(
+    must=[
+        models.FieldCondition(
+            key="city",
+            match=models.MatchValue(
+                value="London",
+            ),
+        )
+    ]
+)
+
+search_queries = [
+    models.QueryRequest(query=[0.2, 0.1, 0.9, 0.7], filter=filter_, limit=3),
+    models.QueryRequest(query=[0.5, 0.3, 0.2, 0.3], filter=filter_, limit=3),
+]
+
+client.query_batch_points(collection_name="{collection_name}", requests=search_queries)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/rust.md
new file mode 100644
index 000000000..8f25eaac7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/rust.md
@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, QueryBatchPointsBuilder, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let filter = Filter::must([Condition::matches("city", "London".to_string())]);
+
+let searches = vec![
+    QueryPointsBuilder::new("{collection_name}")
+        .query(vec![0.1, 0.2, 0.3, 0.4])
+        .limit(3)
+        .filter(filter.clone())
+        .build(),
+    QueryPointsBuilder::new("{collection_name}")
+        .query(vec![0.5, 0.3, 0.2, 0.3])
+        .limit(3)
+        .filter(filter)
+        .build(),
+];
+
+client
+        .query_batch(QueryBatchPointsBuilder::new("{collection_name}", searches))
+        .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/typescript.md
new file mode 100644
index 000000000..6c4916549
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/batch-search/typescript.md
@@ -0,0 +1,33 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+const filter = {
+    must: [
+        {
+            key: "city",
+            match: {
+                value: "London",
+            },
+        },
+    ],
+};
+
+const searches = [
+    {
+        query: [0.2, 0.1, 0.9, 0.7],
+        filter,
+        limit: 3,
+    },
+    {
+        query: [0.5, 0.3, 0.2, 0.3],
+        filter,
+        limit: 3,
+    },
+];
+
+client.queryBatch("{collection_name}", {
+    searches,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/_description.md
new file mode 100644
index 000000000..1bd5e8972
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a query to retrieve points by an existing ID using a specified vector for comparison. There is an option to specify a different collection and vector to reference the ID and vector from another collection for the query.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/csharp.md
new file mode 100644
index 000000000..59f3c0598
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/csharp.md
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  query: Guid.Parse("43cf51e2-8777-4f52-bc74-c2cbde0c8b04"), // <--- point id
+  usingVector: "512d-vector",
+  lookupFrom: new() {
+    CollectionName = "another_collection", // <--- other collection name
+      VectorName = "image-512" // <--- vector name in the other collection
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/go.md
new file mode 100644
index 000000000..8198e8210
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQueryID(qdrant.NewID("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
+	Using:          qdrant.PtrOf("512d-vector"),
+	LookupFrom: &qdrant.LookupLocation{
+		CollectionName: "another_collection",
+		VectorName:     qdrant.PtrOf("image-512"),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/http.md
new file mode 100644
index 000000000..191007065
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": "43cf51e2-8777-4f52-bc74-c2cbde0c8b04", // <--- point id
+    "using": "512d-vector"
+    "lookup_from": {
+        "collection": "another_collection", // <--- other collection name
+        "vector": "image-512" // <--- vector name in the other collection
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/java.md
new file mode 100644
index 000000000..845f83f5a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/java.md
@@ -0,0 +1,26 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.LookupLocation;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import java.util.UUID;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(nearest(UUID.fromString("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
+            .setUsing("512d-vector")
+            .setLookupFrom(
+                LookupLocation.newBuilder()
+                    .setCollectionName("another_collection")
+                    .setVectorName("image-512")
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/python.md
new file mode 100644
index 000000000..c6dedb73f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04",  # <--- point id
+    using="512d-vector",
+    lookup_from=models.LookupLocation(
+        collection="another_collection",  # <--- other collection name
+        vector="image-512",  # <--- vector name in the other collection
+    )
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/rust.md
new file mode 100644
index 000000000..008d252a0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{LookupLocationBuilder, PointId, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .query(Query::new_nearest("43cf51e2-8777-4f52-bc74-c2cbde0c8b04"))
+        .using("512d-vector")
+        .lookup_from(
+            LookupLocationBuilder::new("another_collection")
+                .vector_name("image-512")
+        )
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/typescript.md
new file mode 100644
index 000000000..d3fca34a2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id-with-lookup/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: '43cf51e2-8777-4f52-bc74-c2cbde0c8b04', // <--- point id
+    using: '512d-vector',
+    lookup_from: {
+        collection: 'another_collection', // <--- other collection name
+        vector: 'image-512', // <--- vector name in the other collection
+    }
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/_description.md
new file mode 100644
index 000000000..4900bc82d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/_description.md
@@ -0,0 +1 @@
+This code snippet is used to query points by an existing ID. In this case, the ID specified in the query is "43cf51e2-8777-4f52-bc74-c2cbde0c8b04".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/csharp.md
new file mode 100644
index 000000000..b4cee8908
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/csharp.md
@@ -0,0 +1,10 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: Guid.Parse("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/go.md
new file mode 100644
index 000000000..21d2af5e0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/go.md
@@ -0,0 +1,17 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQueryID(qdrant.NewID("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/http.md
new file mode 100644
index 000000000..033705af7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/http.md
@@ -0,0 +1,6 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": "43cf51e2-8777-4f52-bc74-c2cbde0c8b04" // <--- point id
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/java.md
new file mode 100644
index 000000000..f2ca76285
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/java.md
@@ -0,0 +1,16 @@
+```java
+import java.util.UUID;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+  .setCollectionName("{collectionName}")
+  .setQuery(nearest(UUID.fromString("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
+  .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/python.md
new file mode 100644
index 000000000..a92c473f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/python.md
@@ -0,0 +1,6 @@
+```python
+client.query_points(
+    collection_name="{collection_name}",
+    query="43cf51e2-8777-4f52-bc74-c2cbde0c8b04", # <--- point id
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/rust.md
new file mode 100644
index 000000000..68a9a889d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{Condition, Filter, PointId, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(PointId::new("43cf51e2-8777-4f52-bc74-c2cbde0c8b04")))
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/typescript.md
new file mode 100644
index 000000000..412be1c9d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/by-existing-id/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: '43cf51e2-8777-4f52-bc74-c2cbde0c8b04', // <--- point id
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/_description.md
new file mode 100644
index 000000000..4ed90c656
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/_description.md
@@ -0,0 +1 @@
+To speed up the search process and reduce disk reads, you have the option to disable rescoring by setting the `rescore` parameter to false in the search parameters. Keep in mind that this choice may result in a small decrease in precision.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/csharp.md
new file mode 100644
index 000000000..378469577
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	searchParams: new SearchParams
+	{
+		Quantization = new QuantizationSearchParams { Rescore = false }
+	},
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/go.md
new file mode 100644
index 000000000..2ad01665f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Params: &qdrant.SearchParams{
+		Quantization: &qdrant.QuantizationSearchParams{
+			Rescore: qdrant.PtrOf(true),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/http.md
new file mode 100644
index 000000000..a1f40dec3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "params": {
+        "quantization": {
+            "rescore": false
+        }
+    },
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/java.md
new file mode 100644
index 000000000..97e395675
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/java.md
@@ -0,0 +1,25 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QuantizationSearchParams;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setParams(
+                        SearchParams.newBuilder()
+                                .setQuantization(
+                                        QuantizationSearchParams.newBuilder().setRescore(false).build())
+                                .build())
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/python.md
new file mode 100644
index 000000000..43e932443
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/python.md
@@ -0,0 +1,13 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    search_params=models.SearchParams(
+        quantization=models.QuantizationSearchParams(rescore=False)
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/rust.md
new file mode 100644
index 000000000..aa1622702
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{
+    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .params(
+                SearchParamsBuilder::default()
+                    .quantization(QuantizationSearchParamsBuilder::default().rescore(false)),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/typescript.md
new file mode 100644
index 000000000..3ac7f8bd0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/disable-quantization-rescoring/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    params: {
+        quantization: {
+            rescore: false,
+        },
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/_description.md
new file mode 100644
index 000000000..91e865b4c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a feature to query points from a collection while excluding specific fields, with 'city' being explicitly excluded in this case.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/csharp.md
new file mode 100644
index 000000000..6c3e5ba49
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	payloadSelector: new WithPayloadSelector
+	{
+		Exclude = new PayloadExcludeSelector { Fields = { new string[] { "city" } } }
+	},
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/go.md
new file mode 100644
index 000000000..798395109
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/go.md
@@ -0,0 +1,18 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	WithPayload:    qdrant.NewWithPayloadExclude("city"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/http.md
new file mode 100644
index 000000000..eed32ad94
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/http.md
@@ -0,0 +1,9 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "with_payload": {
+      "exclude": ["city"]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/java.md
new file mode 100644
index 000000000..1a1c6ca2b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/java.md
@@ -0,0 +1,22 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.WithPayloadSelectorFactory.exclude;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setWithPayload(exclude(List.of("city")))
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/python.md
new file mode 100644
index 000000000..093087214
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/python.md
@@ -0,0 +1,13 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    with_payload=models.PayloadSelectorExclude(
+        exclude=["city"],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/rust.md
new file mode 100644
index 000000000..9a8e3cffe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .with_payload(SelectorOptions::Exclude(vec!["city".to_string()].into()))
+            .with_vectors(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/typescript.md
new file mode 100644
index 000000000..ae5d8af6a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/exclude-fields/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  query: [0.2, 0.1, 0.9, 0.7],
+  with_payload: {
+    exclude: ["city"],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/_description.md
new file mode 100644
index 000000000..d55dd3a11
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a hybrid search functionality where you can query points from a collection using both sparse and dense vectors. The code showcases how to combine the results of multiple queries with different vector representations using Reciprocal Rank Fusion (RRF). RRF boosts results that are closer to the top in multiple queries. This hybrid search approach can be useful for obtaining semantic and specific word matching results simultaneously.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/csharp.md
new file mode 100644
index 000000000..3857ffa9a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/csharp.md
@@ -0,0 +1,27 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  prefetch: new List < PrefetchQuery > {
+    new() {
+      Query = new(float, uint)[] {
+          (0.22f, 1), (0.8f, 42),
+        },
+        Using = "sparse",
+        Limit = 20
+    },
+    new() {
+      Query = new float[] {
+          0.01f, 0.45f, 0.67f
+        },
+        Using = "dense",
+        Limit = 20
+    }
+  },
+  query: Fusion.Rrf
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/go.md
new file mode 100644
index 000000000..f03029fa0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Prefetch: []*qdrant.PrefetchQuery{
+		{
+			Query: qdrant.NewQuerySparse([]uint32{1, 42}, []float32{0.22, 0.8}),
+			Using: qdrant.PtrOf("sparse"),
+		},
+		{
+			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
+			Using: qdrant.PtrOf("dense"),
+		},
+	},
+	Query: qdrant.NewQueryFusion(qdrant.Fusion_RRF),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/http.md
new file mode 100644
index 000000000..32a351da9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/http.md
@@ -0,0 +1,22 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "prefetch": [
+        {
+            "query": { 
+                "indices": [1, 42],    // <┐
+                "values": [0.22, 0.8]  // <┴─sparse vector
+             },
+            "using": "sparse",
+            "limit": 20
+        },
+        {
+            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
+            "using": "dense",
+            "limit": 20
+        }
+    ],
+    "query": { "fusion": "rrf" }, // <--- reciprocal rank fusion
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/java.md
new file mode 100644
index 000000000..ffdf6b897
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/java.md
@@ -0,0 +1,32 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import java.util.List;
+
+import static io.qdrant.client.QueryFactory.fusion;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Fusion;
+import io.qdrant.client.grpc.Points.PrefetchQuery;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+    QueryPoints.newBuilder()
+    .setCollectionName("{collection_name}")
+    .addPrefetch(PrefetchQuery.newBuilder()
+      .setQuery(nearest(List.of(0.22f, 0.8f), List.of(1, 42)))
+      .setUsing("sparse")
+      .setLimit(20)
+      .build())
+    .addPrefetch(PrefetchQuery.newBuilder()
+      .setQuery(nearest(List.of(0.01f, 0.45f, 0.67f)))
+      .setUsing("dense")
+      .setLimit(20)
+      .build())
+    .setQuery(fusion(Fusion.RRF))
+    .build())
+  .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/python.md
new file mode 100644
index 000000000..77c071145
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/python.md
@@ -0,0 +1,22 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    prefetch=[
+        models.Prefetch(
+            query=models.SparseVector(indices=[1, 42], values=[0.22, 0.8]),
+            using="sparse",
+            limit=20,
+        ),
+        models.Prefetch(
+            query=[0.01, 0.45, 0.67],  # <-- dense vector
+            using="dense",
+            limit=20,
+        ),
+    ],
+    query=models.FusionQuery(fusion=models.Fusion.RRF),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/rust.md
new file mode 100644
index 000000000..86578aced
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{Fusion, PrefetchQueryBuilder, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest([(1, 0.22), (42, 0.8)].as_slice()))
+            .using("sparse")
+            .limit(20u64)
+        )
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
+            .using("dense")
+            .limit(20u64)
+        )
+        .query(Query::new_fusion(Fusion::Rrf))
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/typescript.md
new file mode 100644
index 000000000..edfe43702
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-basic/typescript.md
@@ -0,0 +1,26 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    prefetch: [
+        {
+            query: {
+                values: [0.22, 0.8],
+                indices: [1, 42],
+            },
+            using: 'sparse',
+            limit: 20,
+        },
+        {
+            query: [0.01, 0.45, 0.67],
+            using: 'dense',
+            limit: 20,
+        },
+    ],
+    query: {
+        fusion: 'rrf',
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/_description.md
new file mode 100644
index 000000000..d0e52ba8d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a complex query setup with multiple techniques. It includes prefetching with both small byte vectors and full dense vectors, along with a multi-vector query using the "colbert" technique. The query includes multiple sub-vectors for more specific search criteria, all combined into a single query for efficient processing.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/csharp.md
new file mode 100644
index 000000000..b37d3ebe5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/csharp.md
@@ -0,0 +1,33 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  prefetch: new List <PrefetchQuery> {
+    new() {
+      Prefetch = {
+          new List <PrefetchQuery> {
+            new() {
+              Query = new float[] { 1, 23, 45, 67 }, // <------------- small byte vector
+                Using = "mrl_byte",
+                Limit = 1000
+            },
+          }
+        },
+        Query = new float[] {0.01f, 0.45f, 0.67f}, // <-- dense vector
+        Using = "full",
+        Limit = 100
+    }
+  },
+  query: new float[][] {
+    [0.1f, 0.2f], // <─┐
+    [0.2f, 0.1f], // < ├─ multi-vector
+    [0.8f, 0.9f]  // < ┘
+  },
+  usingVector: "colbert",
+  limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/go.md
new file mode 100644
index 000000000..38158354c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/go.md
@@ -0,0 +1,36 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Prefetch: []*qdrant.PrefetchQuery{
+		{
+			Prefetch: []*qdrant.PrefetchQuery{
+				{
+					Query: qdrant.NewQueryDense([]float32{1, 23, 45, 67}),
+					Using: qdrant.PtrOf("mrl_byte"),
+					Limit: qdrant.PtrOf(uint64(1000)),
+				},
+			},
+			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
+			Limit: qdrant.PtrOf(uint64(100)),
+			Using: qdrant.PtrOf("full"),
+		},
+	},
+	Query: qdrant.NewQueryMulti([][]float32{
+		{0.1, 0.2},
+		{0.2, 0.1},
+		{0.8, 0.9},
+	}),
+	Using: qdrant.PtrOf("colbert"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/http.md
new file mode 100644
index 000000000..fbfde6466
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/http.md
@@ -0,0 +1,22 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "prefetch": {
+        "prefetch": {
+            "query": [1, 23, 45, 67], // <------ small byte vector
+            "using": "mrl_byte"
+            "limit": 1000
+        },
+        "query": [0.01, 0.45, 0.67, ...], // <-- full dense vector
+        "using": "full"
+        "limit": 100
+    },
+    "query": [           // <─┐
+        [0.1, 0.2, ...], // < │
+        [0.2, 0.1, ...], // < ├─ multi-vector
+        [0.8, 0.9, ...]  // < │
+    ],                   // <─┘       
+    "using": "colbert",
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/java.md
new file mode 100644
index 000000000..3d9bdd433
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/java.md
@@ -0,0 +1,39 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PrefetchQuery;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addPrefetch(
+                PrefetchQuery.newBuilder()
+                    .addPrefetch(
+                        PrefetchQuery.newBuilder()
+                            .setQuery(nearest(1, 23, 45, 67))	// <------------- small byte vector
+                            .setUsing("mrl_byte")
+                            .setLimit(1000)
+                            .build())
+                    .setQuery(nearest(0.01f, 0.45f, 0.67f)) // <-- dense vector
+                    .setUsing("full")
+                    .setLimit(100)
+                    .build())
+            .setQuery(
+                nearest(
+                    new float[][] {
+                      {0.1f, 0.2f},	// <─┐
+                      {0.2f, 0.1f},	// < ├─ multi-vector
+                      {0.8f, 0.9f}	// < ┘
+                    }))
+            .setUsing("colbert")
+            .setLimit(10)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/python.md
new file mode 100644
index 000000000..ee7528f92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/python.md
@@ -0,0 +1,26 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    prefetch=models.Prefetch(
+        prefetch=models.Prefetch(
+            query=[1, 23, 45, 67],  # <------ small byte vector
+            using="mrl_byte",
+            limit=1000,
+        ),
+        query=[0.01, 0.45, 0.67],  # <-- full dense vector
+        using="full",
+        limit=100,
+    ),
+    query=[
+        [0.17, 0.23, 0.52],  # <─┐
+        [0.22, 0.11, 0.63],  # < ├─ multi-vector
+        [0.86, 0.93, 0.12],  # < ┘
+    ],
+    using="colbert",
+    limit=10,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/rust.md
new file mode 100644
index 000000000..4f8e7ef93
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/rust.md
@@ -0,0 +1,27 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .add_prefetch(PrefetchQueryBuilder::default()
+                .query(Query::new_nearest(vec![1.0, 23.0, 45.0, 67.0]))
+                .using("mlr_byte")
+                .limit(1000u64)
+            )
+            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
+            .using("full")
+            .limit(100u64)
+        )
+        .query(Query::new_nearest(vec![
+            vec![0.1, 0.2],
+            vec![0.2, 0.1],
+            vec![0.8, 0.9],
+        ]))
+        .using("colbert")
+        .limit(10u64)
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/typescript.md
new file mode 100644
index 000000000..dbc69e5bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multistage/typescript.md
@@ -0,0 +1,25 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  prefetch: {
+    prefetch: {
+      query: [1, 23, 45, 67], // <------------- small byte vector
+      using: 'mrl_byte',
+      limit: 1000,
+    },
+    query: [0.01, 0.45, 0.67],  // <-- full dense vector
+    using: 'full',
+    limit: 100,
+  },
+  query: [
+    [0.1, 0.2], // <─┐
+    [0.2, 0.1], // < ├─ multi-vector
+    [0.8, 0.9], // < ┘
+  ],
+  using: 'colbert',
+  limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/_description.md
new file mode 100644
index 000000000..d45553ad9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/_description.md
@@ -0,0 +1 @@
+Retrieve a set of 100 results initially based on a single vector, then reevaluate and prioritize the results using a multi-vector approach to obtain the top 10 outcomes.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/csharp.md
new file mode 100644
index 000000000..0af4f5398
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/csharp.md
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  prefetch: new List <PrefetchQuery> {
+    new() {
+      Query = new float[] { 0.01f, 0.45f, 0.67f	},	// <-- dense vector****
+        Limit = 100
+    }
+  },
+  query: new float[][] {
+    [0.1f, 0.2f], // <─┐
+    [0.2f, 0.1f], // < ├─ multi-vector
+    [0.8f, 0.9f]  // < ┘
+  },
+  usingVector: "colbert",
+  limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/go.md
new file mode 100644
index 000000000..14465bb8f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/go.md
@@ -0,0 +1,28 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Prefetch: []*qdrant.PrefetchQuery{
+		{
+			Query: qdrant.NewQueryDense([]float32{0.01, 0.45, 0.67}),
+			Limit: qdrant.PtrOf(uint64(100)),
+		},
+	},
+	Query: qdrant.NewQueryMulti([][]float32{
+		{0.1, 0.2},
+		{0.2, 0.1},
+		{0.8, 0.9},
+	}),
+	Using: qdrant.PtrOf("colbert"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/http.md
new file mode 100644
index 000000000..22044ba7a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/http.md
@@ -0,0 +1,16 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "prefetch": {
+        "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
+        "limit": 100
+    },
+    "query": [           // <─┐
+        [0.1, 0.2, ...], // < │
+        [0.2, 0.1, ...], // < ├─ multi-vector
+        [0.8, 0.9, ...]  // < │
+    ],                   // <─┘       
+    "using": "colbert",
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/java.md
new file mode 100644
index 000000000..d3717fffb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/java.md
@@ -0,0 +1,33 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PrefetchQuery;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addPrefetch(
+                PrefetchQuery.newBuilder()
+                    .setQuery(nearest(0.01f, 0.45f, 0.67f)) // <-- dense vector
+                    .setLimit(100)
+                    .build())
+            .setQuery(
+                nearest(
+                    new float[][] {
+                      {0.1f, 0.2f},	// <─┐
+                      {0.2f, 0.1f},	// < ├─ multi-vector
+                      {0.8f, 0.9f}	// < ┘
+                    }))
+            .setUsing("colbert")
+            .setLimit(10)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/python.md
new file mode 100644
index 000000000..4b00f1dab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/python.md
@@ -0,0 +1,20 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    prefetch=models.Prefetch(
+        query=[0.01, 0.45, 0.67, 0.53],  # <-- dense vector
+        limit=100,
+    ),
+    query=[
+        [0.1, 0.2, 0.32],  # <─┐
+        [0.2, 0.1, 0.52],  # < ├─ multi-vector
+        [0.8, 0.9, 0.93],  # < ┘
+    ],
+    using="colbert",
+    limit=10,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/rust.md
new file mode 100644
index 000000000..e1dbcbcbc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
+            .limit(100u64)
+        )
+        .query(Query::new_nearest(vec![
+            vec![0.1, 0.2],
+            vec![0.2, 0.1],
+            vec![0.8, 0.9],
+        ]))
+        .using("colbert")
+        .limit(10u64)
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/typescript.md
new file mode 100644
index 000000000..414436e07
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-multivector/typescript.md
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    prefetch: {
+        query: [1, 23, 45, 67], // <------------- small byte vector
+        limit: 100,
+    },
+    query: [
+        [0.1, 0.2], // <─┐
+        [0.2, 0.1], // < ├─ multi-vector
+        [0.8, 0.9], // < ┘
+    ],
+    using: 'colbert',
+    limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/_description.md
new file mode 100644
index 000000000..9b3e1ef62
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a scenario where a collection of points can be queried with a focus on the contents of the payload data associated with each point. The example demonstrates the use of dense vectors as queries along with filters based on payload fields such as 'color' with values like "red" or "green". Additionally, the results can be limited and ordered based on a specific payload field such as "price". This functionality allows for more refined and customized querying based on both vector similarity and payload content.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/csharp.md
new file mode 100644
index 000000000..5cc8ac7f7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/csharp.md
@@ -0,0 +1,29 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  prefetch: new List <PrefetchQuery> {
+    new() {
+      Query = new float[] {
+          0.01f, 0.45f, 0.67f
+        },
+        Filter = MatchKeyword("color", "red"),
+        Limit = 10
+    },
+    new() {
+      Query = new float[] {
+          0.01f, 0.45f, 0.67f
+        },
+        Filter = MatchKeyword("color", "green"),
+        Limit = 10
+    }
+  },
+  query: (OrderBy) "price",
+  limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/go.md
new file mode 100644
index 000000000..ce7c78e3f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/go.md
@@ -0,0 +1,37 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Prefetch: []*qdrant.PrefetchQuery{
+		{
+			Query: qdrant.NewQuery(0.01, 0.45, 0.67),
+			Filter: &qdrant.Filter{
+				Must: []*qdrant.Condition{
+					qdrant.NewMatch("color", "red"),
+				},
+			},
+		},
+		{
+			Query: qdrant.NewQuery(0.01, 0.45, 0.67),
+			Filter: &qdrant.Filter{
+				Must: []*qdrant.Condition{
+					qdrant.NewMatch("color", "green"),
+				},
+			},
+		},
+	},
+	Query: qdrant.NewQueryOrderBy(&qdrant.OrderBy{
+		Key: "price",
+	}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/http.md
new file mode 100644
index 000000000..b60204d8c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/http.md
@@ -0,0 +1,32 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "prefetch": [
+        {
+            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
+            "filter": {
+                "must": {
+                    "key": "color",
+                    "match": {
+                        "value": "red"
+                    }
+                }
+            },
+            "limit": 10
+        },
+        {
+            "query": [0.01, 0.45, 0.67, ...], // <-- dense vector
+            "filter": {
+                "must": {
+                    "key": "color",
+                    "match": {
+                        "value": "green"
+                    }
+                }
+            },
+            "limit": 10
+        }
+    ],
+    "query": { "order_by": "price" }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/java.md
new file mode 100644
index 000000000..4b75ff740
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/java.md
@@ -0,0 +1,36 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.QueryFactory.orderBy;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.PrefetchQuery;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addPrefetch(
+                PrefetchQuery.newBuilder()
+                    .setQuery(nearest(0.01f, 0.45f, 0.67f))
+                    .setFilter(
+                        Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+                    .setLimit(10)
+                    .build())
+            .addPrefetch(
+                PrefetchQuery.newBuilder()
+                    .setQuery(nearest(0.01f, 0.45f, 0.67f))
+                    .setFilter(
+                        Filter.newBuilder().addMust(matchKeyword("color", "green")).build())
+                    .setLimit(10)
+                    .build())
+            .setQuery(orderBy("price"))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/python.md
new file mode 100644
index 000000000..f17cd51f4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/python.md
@@ -0,0 +1,32 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    prefetch=[
+        models.Prefetch(
+            query=[0.01, 0.45, 0.67],  # <-- dense vector
+            filter=models.Filter(
+                must=models.FieldCondition(
+                    key="color",
+                    match=models.MatchValue(value="red"),
+                ),
+            ),
+            limit=10,
+        ),
+        models.Prefetch(
+            query=[0.01, 0.45, 0.67],  # <-- dense vector
+            filter=models.Filter(
+                must=models.FieldCondition(
+                    key="color",
+                    match=models.MatchValue(value="green"),
+                ),
+            ),
+            limit=10,
+        ),
+    ],
+    query=models.OrderByQuery(order_by="price"),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/rust.md
new file mode 100644
index 000000000..a2571e44a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/rust.md
@@ -0,0 +1,27 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{Condition, Filter, PrefetchQueryBuilder, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
+            .filter(Filter::must([Condition::matches(
+                "color",
+                "red".to_string(),
+            )]))
+            .limit(10u64)
+        )
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest(vec![0.01, 0.45, 0.67]))
+            .filter(Filter::must([Condition::matches(
+                "color",
+                "green".to_string(),
+            )]))
+            .limit(10u64)
+        )
+        .query(Query::new_order_by("price"))
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/typescript.md
new file mode 100644
index 000000000..c54cf2922
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring-with-payload/typescript.md
@@ -0,0 +1,37 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    prefetch: [
+        {
+            query: [0.01, 0.45, 0.67], // <-- dense vector
+            filter: {
+                must: {
+                    key: 'color',
+                    match: {
+                        value: 'red',
+                    },
+                }
+            },
+            limit: 10,
+        },
+        {
+            query: [0.01, 0.45, 0.67], // <-- dense vector
+            filter: {
+                must: {
+                    key: 'color',
+                    match: {
+                        value: 'green',
+                    },
+                }
+            },
+            limit: 10,
+        },
+    ],
+    query: {
+        order_by: 'price',
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/_description.md
new file mode 100644
index 000000000..d3241b776
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates re-scoring examples where initially 1000 results are fetched using a small byte vector and then re-scored based on a full vector to retrieve the top 10 results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/csharp.md
new file mode 100644
index 000000000..768427ad7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/csharp.md
@@ -0,0 +1,20 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  prefetch: new List<PrefetchQuery> {
+    new() {
+      Query = new float[] { 1,23, 45, 67 }, // <------------- small byte vector
+        Using = "mrl_byte",
+        Limit = 1000
+    }
+  },
+  query: new float[] { 0.01f, 0.299f, 0.45f, 0.67f }, // <-- full vector
+  usingVector: "full",
+  limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/go.md
new file mode 100644
index 000000000..fe97829fb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/go.md
@@ -0,0 +1,25 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Prefetch: []*qdrant.PrefetchQuery{
+		{
+			Query: qdrant.NewQueryDense([]float32{1, 23, 45, 67}),
+			Using: qdrant.PtrOf("mrl_byte"),
+			Limit: qdrant.PtrOf(uint64(1000)),
+		},
+	},
+	Query: qdrant.NewQueryDense([]float32{0.01, 0.299, 0.45, 0.67}),
+	Using: qdrant.PtrOf("full"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/http.md
new file mode 100644
index 000000000..60a4eee61
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "prefetch": {
+        "query": [1, 23, 45, 67], // <------------- small byte vector
+        "using": "mrl_byte"
+        "limit": 1000
+    },
+    "query": [0.01, 0.299, 0.45, 0.67, ...], // <-- full vector
+    "using": "full",
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/java.md
new file mode 100644
index 000000000..c760f5ef2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/java.md
@@ -0,0 +1,27 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PrefetchQuery;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addPrefetch(
+                PrefetchQuery.newBuilder()
+                    .setQuery(nearest(1, 23, 45, 67))	// <------------- small byte vector
+                    .setLimit(1000)
+                    .setUsing("mrl_byte")
+                    .build())
+            .setQuery(nearest(0.01f, 0.299f, 0.45f, 0.67f))	 // <-- full vector
+            .setUsing("full")
+            .setLimit(10)
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/python.md
new file mode 100644
index 000000000..111f15a6f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/python.md
@@ -0,0 +1,17 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    prefetch=models.Prefetch(
+        query=[1, 23, 45, 67],  # <------------- small byte vector
+        using="mrl_byte",
+        limit=1000,
+    ),
+    query=[0.01, 0.299, 0.45, 0.67],  # <-- full vector
+    using="full",
+    limit=10,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/rust.md
new file mode 100644
index 000000000..ae65fdf43
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{PrefetchQueryBuilder, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .add_prefetch(PrefetchQueryBuilder::default()
+            .query(Query::new_nearest(vec![1.0, 23.0, 45.0, 67.0]))
+            .using("mlr_byte")
+            .limit(1000u64)
+        )
+        .query(Query::new_nearest(vec![0.01, 0.299, 0.45, 0.67]))
+        .using("full")
+        .limit(10u64)
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/typescript.md
new file mode 100644
index 000000000..8eeb26674
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/hybrid-rescoring/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  prefetch: {
+    query: [1, 23, 45, 67], // <------------- small byte vector
+    using: 'mrl_byte',
+    limit: 1000,
+  },
+  query: [0.01, 0.299, 0.45, 0.67], // <-- full vector,
+  using: 'full',
+  limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/_description.md
new file mode 100644
index 000000000..f2705a119
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/_description.md
@@ -0,0 +1 @@
+Perform a multivector search within the specified collection by using the `query` endpoint. The request includes a list of arrays representing points to be queried for similarity matching within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/csharp.md
new file mode 100644
index 000000000..9484c3eb8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/csharp.md
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  query: new float[][] {
+    [-0.013f, 0.020f, -0.007f, -0.111f],
+    [-0.030f, -0.055f, 0.001 , 0.072f],
+    [-0.041f, 0.014f, -0.032f, -0.062f],
+  }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/go.md
new file mode 100644
index 000000000..7a0126988
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQueryMulti(
+		[][]float32{
+			{-0.013, 0.020, -0.007, -0.111},
+			{-0.030, -0.055, 0.001, 0.072},
+			{-0.041, 0.014, -0.032, -0.062},
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/http.md
new file mode 100644
index 000000000..a5cee603a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/http.md
@@ -0,0 +1,10 @@
+```http
+POST collections/{collection_name}/points/query
+{
+  "query": [
+    [-0.013,  0.020, -0.007, -0.111, ...],
+    [-0.030, -0.055,  0.001,  0.072, ...],
+    [-0.041,  0.014, -0.032, -0.062, ...]
+  ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/java.md
new file mode 100644
index 000000000..9b3f04481
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/java.md
@@ -0,0 +1,19 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+    .setCollectionName("{collection_name}")
+    .setQuery(nearest(new float[][] {
+        {-0.013f, 0.020f, -0.007f, -0.111f}, 
+        {-0.030f, -0.055f, 0.001f, 0.072f}, 
+        {-0.041f, 0.014f, -0.032f, -0.062f}
+    }))
+    .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/python.md
new file mode 100644
index 000000000..0af63c94a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[
+        [-0.013,  0.020, -0.007, -0.111],
+        [-0.030, -0.055,  0.001,  0.072],
+        [-0.041,  0.014, -0.032, -0.062]
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/rust.md
new file mode 100644
index 000000000..e5452e743
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{ QueryPointsBuilder, VectorInput };
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let res = client.query(
+    QueryPointsBuilder::new("{collection_name}")
+        .query(VectorInput::new_multi(
+            vec![
+                vec![-0.013,  0.020, -0.007, -0.111],
+                vec![-0.030, -0.055,  0.001,  0.072],
+                vec![-0.041,  0.014, -0.032, -0.062],
+            ]
+        ))
+).await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/typescript.md
new file mode 100644
index 000000000..0e7637165
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/multivector/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  "query": [
+    [-0.013, 0.020, -0.007, -0.111],
+    [-0.030, -0.055, 0.001, 0.072],
+    [-0.041, 0.014, -0.032, -0.062]
+  ]
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/_description.md
new file mode 100644
index 000000000..d8984e8b1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a query functionality to search for points in a collection named 'collection_name' using a specified query with four values, limiting the results to three. The search is conducted based on named vectors with the 'image' method specified in the query.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/csharp.md
new file mode 100644
index 000000000..50449e954
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	usingVector: "image",
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/go.md
new file mode 100644
index 000000000..f1c18e6c2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/go.md
@@ -0,0 +1,18 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Using:          qdrant.PtrOf("image"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/http.md
new file mode 100644
index 000000000..4d9561309
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/http.md
@@ -0,0 +1,8 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "using": "image",
+    "limit": 3
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/java.md
new file mode 100644
index 000000000..9b39c6328
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/java.md
@@ -0,0 +1,19 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+        .setUsing("image")
+        .setLimit(3)
+        .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/python.md
new file mode 100644
index 000000000..adab91dc4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/python.md
@@ -0,0 +1,12 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    using="image",
+    limit=3,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/rust.md
new file mode 100644
index 000000000..e5c55fa02
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::QueryPointsBuilder;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .using("image"),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/typescript.md
new file mode 100644
index 000000000..39cc62090
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/named-vector/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  query: [0.2, 0.1, 0.9, 0.7],
+  using: "image",
+  limit: 3,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/_description.md
new file mode 100644
index 000000000..6da935be2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to perform random sampling on a collection of data points. It allows for retrieving a random subset of points, which can be beneficial for tasks like debugging, testing, or facilitating exploratory analysis. The random sampling functionality is accessible through the Universal Query API and can be integrated similarly to typical search operations.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/csharp.md
new file mode 100644
index 000000000..a42267681
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/csharp.md
@@ -0,0 +1,8 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(collectionName: "{collection_name}", query: Sample.Random);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/go.md
new file mode 100644
index 000000000..0dd2f4dee
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/go.md
@@ -0,0 +1,17 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.QueryGroups(context.Background(), &qdrant.QueryPointGroups{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuerySample(qdrant.Sample_Random),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/http.md
new file mode 100644
index 000000000..d29b543bd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/http.md
@@ -0,0 +1,8 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": {
+        "sample": "random"
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/java.md
new file mode 100644
index 000000000..5a12fefc3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/java.md
@@ -0,0 +1,21 @@
+```java
+import static io.qdrant.client.QueryFactory.sample;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.Sample;
+
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+
+client
+    .queryAsync(
+        QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(sample(Sample.Random))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/python.md
new file mode 100644
index 000000000..5189f2d53
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/python.md
@@ -0,0 +1,9 @@
+```python
+from qdrant_client import QdrantClient, models
+
+
+sampled = client.query_points(
+    collection_name="{collection_name}",
+    query=models.SampleQuery(sample=models.Sample.RANDOM)
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/rust.md
new file mode 100644
index 000000000..c7b6eae8a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{Query, QueryPointsBuilder};
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let sampled = client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_sample(Sample::Random))
+    )
+    .await?;
+
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/typescript.md
new file mode 100644
index 000000000..b2f48e8d6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/random-sample/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+const sampled = await client.query("{collection_name}", {
+  query: {
+    sample: "random",
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/_description.md
new file mode 100644
index 000000000..a62279d38
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/_description.md
@@ -0,0 +1 @@
+You can utilize the Query API in Qdrant to perform various types of searches. One of the key functionalities is the Nearest Neighbors Search, which enables you to find vector similarity between points using k-NN algorithm. The API allows for searching by id, providing recommendations with positive and negative examples, conducting discovery searches, scrolling through points with optional filtering, grouping results, ordering points by payload key, performing hybrid searches, optimizing performance for large embeddings with multi-stage search, and getting random points from the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/csharp.md
new file mode 100644
index 000000000..4b10c06a4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/csharp.md
@@ -0,0 +1,10 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+ collectionName: "{collection_name}",
+ query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/go.md
new file mode 100644
index 000000000..94e7f238b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/go.md
@@ -0,0 +1,17 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/http.md
new file mode 100644
index 000000000..357bd86db
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/http.md
@@ -0,0 +1,6 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7] // <--- Dense vector
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/java.md
new file mode 100644
index 000000000..506518864
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/java.md
@@ -0,0 +1,16 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+QdrantClient client = new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(QueryPoints.newBuilder()
+  .setCollectionName("{collectionName}")
+  .setQuery(nearest(List.of(0.2f, 0.1f, 0.9f, 0.7f)))
+  .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/python.md
new file mode 100644
index 000000000..a4cb35db2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/python.md
@@ -0,0 +1,6 @@
+```python
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7], # <--- Dense vector
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/rust.md
new file mode 100644
index 000000000..7f8917ceb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{Condition, Filter, Query, QueryPointsBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(vec![0.2, 0.1, 0.9, 0.7]))
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/typescript.md
new file mode 100644
index 000000000..4f1387696
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/simple-dense/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7], // <--- Dense vector
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/_description.md
new file mode 100644
index 000000000..790e7a3b9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/_description.md
@@ -0,0 +1 @@
+This code snippet allows you to perform a search using sparse vectors. The query includes indices and corresponding values to search within the specified collection using a text-based search approach.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/csharp.md
new file mode 100644
index 000000000..069f6319e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+  collectionName: "{collection_name}",
+  query: new (float, uint)[] {(0.1f, 1), (0.2f, 3), (0.3f, 5), (0.4f, 7)},
+  usingVector: "text",
+  limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/go.md
new file mode 100644
index 000000000..7e4d5063e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQuerySparse(
+		[]uint32{1, 3, 5, 7},
+		[]float32{0.1, 0.2, 0.3, 0.4}),
+	Using: qdrant.PtrOf("text"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/http.md
new file mode 100644
index 000000000..658b45f4c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/http.md
@@ -0,0 +1,10 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": {
+        "indices": [1, 3, 5, 7],
+        "values": [0.1, 0.2, 0.3, 0.4]
+    },
+    "using": "text"
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/java.md
new file mode 100644
index 000000000..2e627e08b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/java.md
@@ -0,0 +1,21 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setUsing("text")
+                .setQuery(nearest(List.of(0.1f, 0.2f, 0.3f, 0.4f), List.of(1, 3, 5, 7)))
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/python.md
new file mode 100644
index 000000000..1927ce990
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/python.md
@@ -0,0 +1,12 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+
+result = client.query_points(
+    collection_name="{collection_name}",
+    query=models.SparseVector(indices=[1, 3, 5, 7], values=[0.1, 0.2, 0.3, 0.4]),
+    using="text",
+).points
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/rust.md
new file mode 100644
index 000000000..825061a26
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::QueryPointsBuilder;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![(1, 0.2), (3, 0.1), (5, 0.9), (7, 0.7)])
+            .limit(10)
+            .using("text"),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/typescript.md
new file mode 100644
index 000000000..e100beafb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/sparse-vectors/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: {
+        indices: [1, 3, 5, 7],
+        values: [0.1, 0.2, 0.3, 0.4]
+    },
+    using: "text",
+    limit: 3,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/_description.md
new file mode 100644
index 000000000..3ffc75fc4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/_description.md
@@ -0,0 +1 @@
+By setting `"rescore": false`, the code snippet suggests disabling the re-scoring feature during query point searches in order to enhance search speed, especially in systems with high disk latency. This optimization aims to minimize the impact of disk reads and improve the efficiency of the search operation.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/csharp.md
new file mode 100644
index 000000000..378469577
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	searchParams: new SearchParams
+	{
+		Quantization = new QuantizationSearchParams { Rescore = false }
+	},
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/go.md
new file mode 100644
index 000000000..20cafb0c7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Params: &qdrant.SearchParams{
+		Quantization: &qdrant.QuantizationSearchParams{
+			Rescore: qdrant.PtrOf(false),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/http.md
new file mode 100644
index 000000000..a1f40dec3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "params": {
+        "quantization": {
+            "rescore": false
+        }
+    },
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/java.md
new file mode 100644
index 000000000..97e395675
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/java.md
@@ -0,0 +1,25 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QuantizationSearchParams;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setParams(
+                        SearchParams.newBuilder()
+                                .setQuantization(
+                                        QuantizationSearchParams.newBuilder().setRescore(false).build())
+                                .build())
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/python.md
new file mode 100644
index 000000000..43e932443
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/python.md
@@ -0,0 +1,13 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    search_params=models.SearchParams(
+        quantization=models.QuantizationSearchParams(rescore=False)
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/rust.md
new file mode 100644
index 000000000..aa1622702
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{
+    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .params(
+                SearchParamsBuilder::default()
+                    .quantization(QuantizationSearchParamsBuilder::default().rescore(false)),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/typescript.md
new file mode 100644
index 000000000..3ac7f8bd0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-disabled-rescoring/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    params: {
+        quantization: {
+            rescore: false,
+        },
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/_description.md
new file mode 100644
index 000000000..3828e982f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/_description.md
@@ -0,0 +1 @@
+Retrieve vectors from a collection by specifying a query and applying a filter to only retrieve vectors that have a `group_id` matching a specific value like "user_1". You can also set a limit on the number of vectors to be returned.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/csharp.md
new file mode 100644
index 000000000..bc8d532c7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/csharp.md
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.1f, 0.1f, 0.9f },
+	filter: MatchKeyword("group_id", "user_1"),
+	limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/go.md
new file mode 100644
index 000000000..c1e4532da
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.1, 0.1, 0.9),
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("group_id", "user_1"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/http.md
new file mode 100644
index 000000000..63f2884d8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/http.md
@@ -0,0 +1,17 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.1, 0.1, 0.9],
+    "filter": {
+        "must": [
+            {
+                "key": "group_id",
+                "match": {
+                    "value": "user_1"
+                }
+            }
+        ]
+    },
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/java.md
new file mode 100644
index 000000000..a68f17507
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/java.md
@@ -0,0 +1,24 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setFilter(
+                        Filter.newBuilder().addMust(matchKeyword("group_id", "user_1")).build())
+                .setQuery(nearest(0.1f, 0.1f, 0.9f))
+                .setLimit(10)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/python.md
new file mode 100644
index 000000000..9d755cc63
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/python.md
@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.1, 0.1, 0.9],
+    query_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="group_id",
+                match=models.MatchValue(
+                    value="user_1",
+                ),
+            )
+        ]
+    ),
+    limit=10,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/rust.md
new file mode 100644
index 000000000..e6951086f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/rust.md
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.1, 0.1, 0.9])
+            .limit(10)
+            .filter(Filter::must([Condition::matches(
+                "group_id",
+                "user_1".to_string(),
+            )])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/typescript.md
new file mode 100644
index 000000000..83148a295
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-filter-by-group-id/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.1, 0.1, 0.9],
+    filter: {
+        must: [{ key: "group_id", match: { value: "user_1" } }],
+    },
+    limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/_description.md
new file mode 100644
index 000000000..9402e9aec
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a technique to disable quantization for querying points from a collection. By setting the "ignore" parameter to true within the request parameters, quantization can be turned off, allowing for more precise search results without quantization affecting the output.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/csharp.md
new file mode 100644
index 000000000..db4802054
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/csharp.md
@@ -0,0 +1,16 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	searchParams: new SearchParams
+	{
+		Quantization = new QuantizationSearchParams { Ignore = true }
+	},
+	limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/go.md
new file mode 100644
index 000000000..0967f696d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Params: &qdrant.SearchParams{
+		Quantization: &qdrant.QuantizationSearchParams{
+			Ignore: qdrant.PtrOf(false),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/http.md
new file mode 100644
index 000000000..c35e527bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "params": {
+        "quantization": {
+            "ignore": true
+        }
+    },
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/java.md
new file mode 100644
index 000000000..46896d119
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/java.md
@@ -0,0 +1,25 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QuantizationSearchParams;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setParams(
+                        SearchParams.newBuilder()
+                                .setQuantization(
+                                        QuantizationSearchParams.newBuilder().setIgnore(true).build())
+                                .build())
+                .setLimit(10)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/python.md
new file mode 100644
index 000000000..3f2a75eb3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/python.md
@@ -0,0 +1,15 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    search_params=models.SearchParams(
+        quantization=models.QuantizationSearchParams(
+            ignore=True,
+        )
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/rust.md
new file mode 100644
index 000000000..b6e26d556
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/rust.md
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{
+    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .params(
+                SearchParamsBuilder::default()
+                    .quantization(QuantizationSearchParamsBuilder::default().ignore(true)),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/typescript.md
new file mode 100644
index 000000000..1c804c82b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-ignored-quantization/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    params: {
+        quantization: {
+            ignore: true,
+        },
+    },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/_description.md
new file mode 100644
index 000000000..c36aebbc2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to paginate search results by specifying an offset to skip the initial results and retrieve the subsequent results. The query includes parameters to request points with vectors and payloads, set a limit on the number of results returned, and an offset of 100 to skip the first 100 results before returning the next set of results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/csharp.md
new file mode 100644
index 000000000..fd71b4d92
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/csharp.md
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+    payloadSelector: true,
+    vectorsSelector: true,
+    limit: 10,
+    offset: 100
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/go.md
new file mode 100644
index 000000000..88bf5eac9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	WithPayload:    qdrant.NewWithPayload(true),
+	WithVectors:    qdrant.NewWithVectors(true),
+	Offset:         qdrant.PtrOf(uint64(100)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/http.md
new file mode 100644
index 000000000..9d99be2a2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/http.md
@@ -0,0 +1,10 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "with_vectors": true,
+    "with_payload": true,
+    "limit": 10,
+    "offset": 100
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/java.md
new file mode 100644
index 000000000..426c924f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/java.md
@@ -0,0 +1,25 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.WithVectorsSelectorFactory;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.WithPayloadSelectorFactory.enable;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setWithPayload(enable(true))
+                .setWithVectors(WithVectorsSelectorFactory.enable(true))
+                .setLimit(10)
+                .setOffset(100)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/python.md
new file mode 100644
index 000000000..c372451dd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    with_vectors=True,
+    with_payload=True,
+    limit=10,
+    offset=100,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/rust.md
new file mode 100644
index 000000000..76986e3bc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::QueryPointsBuilder;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .with_payload(true)
+            .with_vectors(true)
+            .limit(10)
+            .offset(100),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/typescript.md
new file mode 100644
index 000000000..fdaccfc03
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-offset/typescript.md
@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  query: [0.2, 0.1, 0.9, 0.7],
+  with_vector: true,
+  with_payload: true,
+  limit: 10,
+  offset: 100,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/_description.md
new file mode 100644
index 000000000..d70130c14
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/_description.md
@@ -0,0 +1,3 @@
+Fine-Tuning Search Parameters
+
+You can optimize your search by adjusting key parameters such as `hnsw_ef` and `exact`. `hnsw_ef` represents the number of neighbors visited during search, with a higher value leading to improved accuracy but slower speed. Setting `exact` to `true` enables precise search, albeit at a slower pace. This allows you to make comparisons between search results achieved with varied `hnsw_ef` values and the actual ground truth.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/csharp.md
new file mode 100644
index 000000000..85867e0db
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	searchParams: new SearchParams { HnswEf = 128, Exact = false },
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/go.md
new file mode 100644
index 000000000..50f73519f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Params: &qdrant.SearchParams{
+		HnswEf: qdrant.PtrOf(uint64(128)),
+		Exact:  qdrant.PtrOf(false),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/http.md
new file mode 100644
index 000000000..4671f98bf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "params": {
+        "hnsw_ef": 128,
+        "exact": false
+    },
+    "limit": 3
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/java.md
new file mode 100644
index 000000000..339ba78bd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/java.md
@@ -0,0 +1,20 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setParams(SearchParams.newBuilder().setHnswEf(128).setExact(false).build())
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/python.md
new file mode 100644
index 000000000..324bc3dd1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/python.md
@@ -0,0 +1,12 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    search_params=models.SearchParams(hnsw_ef=128, exact=False),
+    limit=3,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/rust.md
new file mode 100644
index 000000000..8737eb88c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{QueryPointsBuilder, SearchParamsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .params(SearchParamsBuilder::default().hnsw_ef(128).exact(false)),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/typescript.md
new file mode 100644
index 000000000..ecc710e15
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-params/typescript.md
@@ -0,0 +1,14 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    params: {
+        hnsw_ef: 128,
+        exact: false,
+    },
+    limit: 3,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/_description.md
new file mode 100644
index 000000000..343055d7c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates the functionality to include payload and vectors in the query results. By setting the `with_vectors` and `with_payload` parameters to true, additional stored information is returned alongside the query results. This allows for a more detailed and comprehensive retrieval process.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/csharp.md
new file mode 100644
index 000000000..6a3fb283a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	payloadSelector: true,
+	vectorsSelector: true,
+	limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/go.md
new file mode 100644
index 000000000..f7c694d13
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	WithPayload:    qdrant.NewWithPayload(true),
+	WithVectors:    qdrant.NewWithVectors(true),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/http.md
new file mode 100644
index 000000000..ba7acb871
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/http.md
@@ -0,0 +1,8 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "with_vectors": true,
+    "with_payload": true
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/java.md
new file mode 100644
index 000000000..5634d3df6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/java.md
@@ -0,0 +1,23 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.WithVectorsSelectorFactory;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.WithPayloadSelectorFactory.enable;
+
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setWithPayload(enable(true))
+                .setWithVectors(WithVectorsSelectorFactory.enable(true))
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/python.md
new file mode 100644
index 000000000..2c5b5b272
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/python.md
@@ -0,0 +1,8 @@
+```python
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    with_vectors=True,
+    with_payload=True,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/rust.md
new file mode 100644
index 000000000..b98a8caad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::QueryPointsBuilder;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .with_payload(true)
+            .with_vectors(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/typescript.md
new file mode 100644
index 000000000..94bbf3a77
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-and-vectors/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+client.query("{collection_name}", {
+  query: [0.2, 0.1, 0.9, 0.7],
+  with_vector: true,
+  with_payload: true,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/_description.md
new file mode 100644
index 000000000..d93206cb7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to send a POST request to query points from a collection. It includes a query array and specifies certain payload fields to be included in the response, such as 'city', 'village', and 'town'. The `with_payload` parameter helps to filter the payload and retrieve only the specified fields.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/csharp.md
new file mode 100644
index 000000000..3a6915b90
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+    payloadSelector: new WithPayloadSelector
+    {
+        Include = new PayloadIncludeSelector
+        {
+            Fields = { new string[] { "city", "village", "town" } }
+        }
+    },
+    limit: 3
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/go.md
new file mode 100644
index 000000000..383010bee
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/go.md
@@ -0,0 +1,18 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	WithPayload:    qdrant.NewWithPayloadInclude("city", "village", "town"),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/http.md
new file mode 100644
index 000000000..fb1c73425
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/http.md
@@ -0,0 +1,7 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "with_payload": ["city", "village", "town"]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/java.md
new file mode 100644
index 000000000..fbd1af352
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/java.md
@@ -0,0 +1,22 @@
+```java
+import java.util.List;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QueryPoints;
+
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.WithPayloadSelectorFactory.include;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setWithPayload(include(List.of("city", "village", "town")))
+                .setLimit(3)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/python.md
new file mode 100644
index 000000000..1a0b7bb9c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    with_payload=["city", "village", "town"],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/rust.md
new file mode 100644
index 000000000..538e3b87b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/rust.md
@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::qdrant::{with_payload_selector::SelectorOptions, QueryPointsBuilder};
+use qdrant_client::Qdrant;
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(3)
+            .with_payload(SelectorOptions::Include(
+                vec![
+                    "city".to_string(),
+                    "village".to_string(),
+                    "town".to_string(),
+                ]
+                .into(),
+            ))
+            .with_vectors(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/typescript.md
new file mode 100644
index 000000000..1cbb52a39
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-payload-fields/typescript.md
@@ -0,0 +1,10 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+  query: [0.2, 0.1, 0.9, 0.7],
+  with_payload: ["city", "village", "town"],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/_description.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/_description.md
new file mode 100644
index 000000000..32ba58ad9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/_description.md
@@ -0,0 +1,2 @@
+Description: 
+This code snippet demonstrates a POST request to query points from a specified collection. The query contains an array of values along with parameters for quantization, where quantization is enabled with oversampling set to 2.0. The limit parameter is also included to restrict the number of results to 10. The search process can be controlled by additional options specified in the request.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/csharp.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/csharp.md
new file mode 100644
index 000000000..7bfebbce5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/csharp.md
@@ -0,0 +1,21 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.QueryAsync(
+	collectionName: "{collection_name}",
+	query: new float[] { 0.2f, 0.1f, 0.9f, 0.7f },
+	searchParams: new SearchParams
+	{
+		Quantization = new QuantizationSearchParams
+		{
+			Ignore = false,
+			Rescore = true,
+			Oversampling = 2.0
+		}
+	},
+	limit: 10
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/go.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/go.md
new file mode 100644
index 000000000..b6621b2c0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Query(context.Background(), &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query:          qdrant.NewQuery(0.2, 0.1, 0.9, 0.7),
+	Params: &qdrant.SearchParams{
+		Quantization: &qdrant.QuantizationSearchParams{
+			Ignore:       qdrant.PtrOf(false),
+			Rescore:      qdrant.PtrOf(true),
+			Oversampling: qdrant.PtrOf(2.0),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/http.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/http.md
new file mode 100644
index 000000000..6c6a720fa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/http.md
@@ -0,0 +1,14 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+    "query": [0.2, 0.1, 0.9, 0.7],
+    "params": {
+        "quantization": {
+            "ignore": false,
+            "rescore": true,
+            "oversampling": 2.0
+        }
+    },
+    "limit": 10
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/java.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/java.md
new file mode 100644
index 000000000..acdf1318a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/java.md
@@ -0,0 +1,29 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.QuantizationSearchParams;
+import io.qdrant.client.grpc.Points.QueryPoints;
+import io.qdrant.client.grpc.Points.SearchParams;
+
+import static io.qdrant.client.QueryFactory.nearest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.queryAsync(
+        QueryPoints.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setQuery(nearest(0.2f, 0.1f, 0.9f, 0.7f))
+                .setParams(
+                        SearchParams.newBuilder()
+                                .setQuantization(
+                                        QuantizationSearchParams.newBuilder()
+                                                .setIgnore(false)
+                                                .setRescore(true)
+                                                .setOversampling(2.0)
+                                                .build())
+                                .build())
+                .setLimit(10)
+                .build())
+        .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/python.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/python.md
new file mode 100644
index 000000000..d9e2cc127
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/python.md
@@ -0,0 +1,17 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=[0.2, 0.1, 0.9, 0.7],
+    search_params=models.SearchParams(
+        quantization=models.QuantizationSearchParams(
+            ignore=False,
+            rescore=True,
+            oversampling=2.0,
+        )
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/rust.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/rust.md
new file mode 100644
index 000000000..a12231ec0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/rust.md
@@ -0,0 +1,24 @@
+```rust
+use qdrant_client::qdrant::{
+    QuantizationSearchParamsBuilder, QueryPointsBuilder, SearchParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+    
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(vec![0.2, 0.1, 0.9, 0.7])
+            .limit(10)
+            .params(
+                SearchParamsBuilder::default().quantization(
+                    QuantizationSearchParamsBuilder::default()
+                        .ignore(false)
+                        .rescore(true)
+                        .oversampling(2.0),
+                ),
+            ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/typescript.md b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/typescript.md
new file mode 100644
index 000000000..8432f935a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/query-points/with-quantization-oversampling/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.query("{collection_name}", {
+    query: [0.2, 0.1, 0.9, 0.7],
+    params: {
+        quantization: {
+            ignore: false,
+            rescore: true,
+            oversampling: 2.0,
+        },
+    },
+    limit: 10,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/_description.md
new file mode 100644
index 000000000..17bb8319b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/_description.md
@@ -0,0 +1 @@
+This code snippet represents a method for retrieving points by their ids from a collection. The function allows users to specify the ids of the points to be retrieved as part of a POST request to the specified endpoint. The provided ids are an array of integers, indicating the specific points to retrieve.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/csharp.md
new file mode 100644
index 000000000..e2b1af932
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.RetrieveAsync(
+	collectionName: "{collection_name}",
+	ids: [0, 30, 100],
+	withPayload: false,
+	withVectors: false
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/go.md
new file mode 100644
index 000000000..683aa6a1d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Get(context.Background(), &qdrant.GetPoints{
+	CollectionName: "{collection_name}",
+	Ids: []*qdrant.PointId{
+		qdrant.NewIDNum(0), qdrant.NewIDNum(3), qdrant.NewIDNum(100),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/http.md
new file mode 100644
index 000000000..63203a632
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/http.md
@@ -0,0 +1,6 @@
+```http
+POST /collections/{collection_name}/points
+{
+    "ids": [0, 3, 100]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/java.md
new file mode 100644
index 000000000..8df106c5b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/java.md
@@ -0,0 +1,9 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+
+client
+    .retrieveAsync("{collection_name}", List.of(id(0), id(30), id(100)), false, false, null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/python.md
new file mode 100644
index 000000000..2429d21c5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/python.md
@@ -0,0 +1,6 @@
+```python
+client.retrieve(
+    collection_name="{collection_name}",
+    ids=[0, 3, 100],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/rust.md
new file mode 100644
index 000000000..b7465f2c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/rust.md
@@ -0,0 +1,10 @@
+```rust
+use qdrant_client::qdrant::GetPointsBuilder;
+
+client
+    .get_points(GetPointsBuilder::new(
+        "{collection_name}",
+        vec![0.into(), 30.into(), 100.into()],
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/typescript.md
new file mode 100644
index 000000000..18c00bfad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/simple/typescript.md
@@ -0,0 +1,5 @@
+```typescript
+client.retrieve("{collection_name}", {
+  ids: [0, 3, 100],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/_description.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/_description.md
new file mode 100644
index 000000000..211eae96a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/_description.md
@@ -0,0 +1 @@
+Retrieve a single point from a collection using the specified point ID. The method supports additional parameters `with_vectors` and `with_payload` to indicate which parts of the point should be included in the result, optimizing data transmission by excluding unnecessary information.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/http.md b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/http.md
new file mode 100644
index 000000000..f021356cd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/retrieve-points/single/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections/{collection_name}/points/{point_id}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/_description.md
new file mode 100644
index 000000000..7eb526918
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/_description.md
@@ -0,0 +1 @@
+Retrieve a single point based on a specified filter condition from a collection of points without being aware of the specific identifiers. It allows for fetching points based on a defined filter criterion. The request includes criteria for filtering points by properties like color, where only points with a color value of "red" will be returned. The response will contain one point with additional payload information, and the vector information will not be included. This functionality enables efficient iteration through points that match the specified filter.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/csharp.md
new file mode 100644
index 000000000..2df01ba08
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("color", "red"),
+	limit: 1,
+	payloadSelector: true
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/go.md
new file mode 100644
index 000000000..2e5af805d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+	Limit:       qdrant.PtrOf(uint32(1)),
+	WithPayload: qdrant.NewWithPayload(true),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/http.md
new file mode 100644
index 000000000..095393ecd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/http.md
@@ -0,0 +1,18 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            {
+                "key": "color",
+                "match": {
+                    "value": "red"
+                }
+            }
+        ]
+    },
+    "limit": 1,
+    "with_payload": true,
+    "with_vector": false
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/java.md
new file mode 100644
index 000000000..dc013faa1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/java.md
@@ -0,0 +1,17 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.WithPayloadSelectorFactory.enable;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(Filter.newBuilder().addMust(matchKeyword("color", "red")).build())
+            .setLimit(1)
+            .setWithPayload(enable(true))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/python.md
new file mode 100644
index 000000000..9f05d72a5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/python.md
@@ -0,0 +1,13 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
+        ]
+    ),
+    limit=1,
+    with_payload=True,
+    with_vectors=False,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/rust.md
new file mode 100644
index 000000000..ccb80d8f9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}")
+            .filter(Filter::must([Condition::matches(
+                "color",
+                "red".to_string(),
+            )]))
+            .limit(1)
+            .with_payload(true)
+            .with_vectors(false),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/typescript.md
new file mode 100644
index 000000000..3d5f6cd4d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-and-params/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "color",
+        match: {
+          value: "red",
+        },
+      },
+    ],
+  },
+  limit: 1,
+  with_payload: true,
+  with_vector: false,
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/_description.md
new file mode 100644
index 000000000..6f48e7c2a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/_description.md
@@ -0,0 +1 @@
+Searches for points within a specified collection based on the dense `image` vector. It filters points by searching for those that have the particular vector named `image`. Points may have a variety of vectors; this filter narrows the search to points with the specific `image` vector defined. If your collection does not have named vectors, ensure to use an empty string (`""`) as the name for filtering.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/csharp.md
new file mode 100644
index 000000000..e2ea2da32
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/csharp.md
@@ -0,0 +1,8 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(collectionName: "{collection_name}", filter: HasVector("image"));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/go.md
new file mode 100644
index 000000000..5b5cc473f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewHasVector(
+        "image",
+			),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/http.md
new file mode 100644
index 000000000..af1ef72bb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/http.md
@@ -0,0 +1,10 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            { "has_vector": "image" }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/java.md
new file mode 100644
index 000000000..c32dbce82
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/java.md
@@ -0,0 +1,20 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.hasVector;
+import static io.qdrant.client.PointIdFactory.id;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMust(hasVector("image"))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/python.md
new file mode 100644
index 000000000..a550ae8ed
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/python.md
@@ -0,0 +1,14 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.HasVectorCondition(has_vector="image"),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/rust.md
new file mode 100644
index 000000000..60ec15b98
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+    
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}")
+            .filter(Filter::must([Condition::has_vector("image")])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/typescript.md
new file mode 100644
index 000000000..514e9c61f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-has-vector/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        has_vector: "image",
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/_description.md
new file mode 100644
index 000000000..f028a763f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/_description.md
@@ -0,0 +1 @@
+This query is designed to retrieve points from a collection based on specific criteria. In this case, the query is filtering for points related to the sightseeing location "Osaka Castle" within the nested array of cities for each country. The result will only include points linked to this sightseeing location.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/csharp.md
new file mode 100644
index 000000000..9a4b24236
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("country.cities[].sightseeing", "Germany")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/go.md
new file mode 100644
index 000000000..1ffef4db4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Should: []*qdrant.Condition{
+			qdrant.NewMatch("country.cities[].sightseeing", "Germany"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/http.md
new file mode 100644
index 000000000..9e39773e6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/http.md
@@ -0,0 +1,15 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "should": [
+            {
+                "key": "country.cities[].sightseeing",
+                "match": {
+                    "value": "Osaka Castle"
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/java.md
new file mode 100644
index 000000000..aada414a6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/java.md
@@ -0,0 +1,17 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addShould(matchKeyword("country.cities[].sightseeing", "Germany"))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/python.md
new file mode 100644
index 000000000..9234ffba7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/python.md
@@ -0,0 +1,13 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        should=[
+            models.FieldCondition(
+                key="country.cities[].sightseeing",
+                match=models.MatchValue(value="Osaka Castle"),
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/rust.md
new file mode 100644
index 000000000..42ab9de47
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
+            Condition::matches("country.cities[].sightseeing", "Osaka Castle".to_string()),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/typescript.md
new file mode 100644
index 000000000..322d30836
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array-match/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    should: [
+      {
+        key: "country.cities[].sightseeing",
+        match: { value: "Osaka Castle" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/_description.md
new file mode 100644
index 000000000..20cd3b211
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/_description.md
@@ -0,0 +1 @@
+This code snippet showcases a filtering setup that allows searching for specific values within nested arrays. In this case, it focuses on retrieving data where the population of cities within a country is equal to or greater than a certain value. The notation `country.cities[].population` targets these nested values efficiently.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/csharp.md
new file mode 100644
index 000000000..285a26d8a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: Range("country.cities[].population", new Qdrant.Client.Grpc.Range { Gte = 9.0 })
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/go.md
new file mode 100644
index 000000000..23fb9c100
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Should: []*qdrant.Condition{
+			qdrant.NewRange("country.cities[].population", &qdrant.Range{
+				Gte: qdrant.PtrOf(9.0),
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/http.md
new file mode 100644
index 000000000..184e456a8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/http.md
@@ -0,0 +1,15 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "should": [
+            {
+                "key": "country.cities[].population",
+                "range": {
+                    "gte": 9.0,
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/java.md
new file mode 100644
index 000000000..390a16bea
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/java.md
@@ -0,0 +1,21 @@
+```java
+import static io.qdrant.client.ConditionFactory.range;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.Range;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addShould(
+                        range(
+                            "country.cities[].population",
+                            Range.newBuilder().setGte(9.0).build()))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/python.md
new file mode 100644
index 000000000..62e1fbc21
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/python.md
@@ -0,0 +1,18 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        should=[
+            models.FieldCondition(
+                key="country.cities[].population",
+                range=models.Range(
+                    gt=None,
+                    gte=9.0,
+                    lt=None,
+                    lte=None,
+                ),
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/rust.md
new file mode 100644
index 000000000..a3ff6d403
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/rust.md
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, Range, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
+            Condition::range(
+                "country.cities[].population",
+                Range {
+                    gte: Some(9.0),
+                    ..Default::default()
+                },
+            ),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/typescript.md
new file mode 100644
index 000000000..aee18ced4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-array/typescript.md
@@ -0,0 +1,17 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    should: [
+      {
+        key: "country.cities[].population",
+        range: {
+          gt: null,
+          gte: 9.0,
+          lt: null,
+          lte: null,
+        },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/_description.md
new file mode 100644
index 000000000..1cc448bc5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/_description.md
@@ -0,0 +1 @@
+This code snippet allows you to perform a search operation on a collection by specifying a filter condition based on a nested field. In this case, the search is filtering points where the `country.name` field matches the value "Germany". This enables you to retrieve scroll points that meet the specified criteria.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/csharp.md
new file mode 100644
index 000000000..c03f3d35b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/csharp.md
@@ -0,0 +1,9 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(collectionName: "{collection_name}", filter: MatchKeyword("country.name", "Germany"));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/go.md
new file mode 100644
index 000000000..107fc0a00
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Should: []*qdrant.Condition{
+			qdrant.NewMatch("country.name", "Germany"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/http.md
new file mode 100644
index 000000000..fd055f8f3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/http.md
@@ -0,0 +1,15 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "should": [
+            {
+                "key": "country.name",
+                "match": {
+                    "value": "Germany"
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/java.md
new file mode 100644
index 000000000..13ae031b5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/java.md
@@ -0,0 +1,17 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addShould(matchKeyword("country.name", "Germany"))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/python.md
new file mode 100644
index 000000000..c9b7d1c50
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/python.md
@@ -0,0 +1,12 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        should=[
+            models.FieldCondition(
+                key="country.name", match=models.MatchValue(value="Germany")
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/rust.md
new file mode 100644
index 000000000..a4820d22f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
+            Condition::matches("country.name", "Germany".to_string()),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/typescript.md
new file mode 100644
index 000000000..8631b835b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-on-nested-fields/typescript.md
@@ -0,0 +1,12 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    should: [
+      {
+        key: "country.name",
+        match: { value: "Germany" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/_description.md
new file mode 100644
index 000000000..eca4c3446
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/_description.md
@@ -0,0 +1 @@
+This code snippet represents a query that filters data from a collection based on specific criteria. In this case, it filters points that have "meat" in the 'food' field of the 'diet' array and where the 'likes' field of the 'diet' array has a boolean value of true.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/csharp.md
new file mode 100644
index 000000000..5358363b2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("diet[].food", "meat") & Match("diet[].likes", true)
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/go.md
new file mode 100644
index 000000000..209bc58b8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("diet[].food", "meat"),
+			qdrant.NewMatchBool("diet[].likes", true),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/http.md
new file mode 100644
index 000000000..a6aac2326
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/http.md
@@ -0,0 +1,21 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            {
+                "key": "diet[].food",
+                  "match": {
+                    "value": "meat"
+                }
+            },
+            {
+                "key": "diet[].likes",
+                  "match": {
+                    "value": true
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/java.md
new file mode 100644
index 000000000..bd00089c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/java.md
@@ -0,0 +1,26 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.match;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addAllMust(
+                        List.of(matchKeyword("diet[].food", "meat"), match("diet[].likes", true)))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/python.md
new file mode 100644
index 000000000..46379dc7b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/python.md
@@ -0,0 +1,15 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="diet[].food", match=models.MatchValue(value="meat")
+            ),
+            models.FieldCondition(
+                key="diet[].likes", match=models.MatchValue(value=True)
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/rust.md
new file mode 100644
index 000000000..aea9b95b4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/rust.md
@@ -0,0 +1,12 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
+            Condition::matches("diet[].food", "meat".to_string()),
+            Condition::matches("diet[].likes", true),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/typescript.md
new file mode 100644
index 000000000..49e2af032
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-multiple-nested/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "diet[].food",
+        match: { value: "meat" },
+      },
+      {
+        key: "diet[].likes",
+        match: { value: true },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/_description.md
new file mode 100644
index 000000000..b6adf100c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a POST request to filter data in a specific collection. The request includes a filter specifying nested conditions on elements within the data array. The nested conditions check for elements with a 'diet' key that matches 'meat' in the 'food' key and 'true' in the 'likes' key. The filter also includes a condition to check if the data has an ID of '1'. It notes that the 'has_id' condition is not supported within the nested filter and should be placed in an adjacent 'must' clause if needed.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/csharp.md
new file mode 100644
index 000000000..f06e5d3eb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true)) & HasId(1)
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/go.md
new file mode 100644
index 000000000..d504e6bdb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/go.md
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewNestedFilter("diet", &qdrant.Filter{
+				Must: []*qdrant.Condition{
+					qdrant.NewMatch("food", "meat"),
+					qdrant.NewMatchBool("likes", true),
+				},
+			}),
+			qdrant.NewHasID(qdrant.NewIDNum(1)),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/http.md
new file mode 100644
index 000000000..a02e69f80
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/http.md
@@ -0,0 +1,35 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+   "filter":{
+      "must":[
+         {
+            "nested":{
+               "key":"diet",
+               "filter":{
+                  "must":[
+                     {
+                        "key":"food",
+                        "match":{
+                           "value":"meat"
+                        }
+                     },
+                     {
+                        "key":"likes",
+                        "match":{
+                           "value":true
+                        }
+                     }
+                  ]
+               }
+            }
+         },
+         {
+            "has_id":[
+               1
+            ]
+         }
+      ]
+   }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/java.md
new file mode 100644
index 000000000..222011cbc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/java.md
@@ -0,0 +1,31 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.hasId;
+import static io.qdrant.client.ConditionFactory.match;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.ConditionFactory.nested;
+import static io.qdrant.client.PointIdFactory.id;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMust(
+                        nested(
+                            "diet",
+                            Filter.newBuilder()
+                                .addAllMust(
+                                    List.of(
+                                        matchKeyword("food", "meat"), match("likes", true)))
+                                .build()))
+                    .addMust(hasId(id(1)))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/python.md
new file mode 100644
index 000000000..380b47f67
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/python.md
@@ -0,0 +1,25 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.NestedCondition(
+                nested=models.Nested(
+                    key="diet",
+                    filter=models.Filter(
+                        must=[
+                            models.FieldCondition(
+                                key="food", match=models.MatchValue(value="meat")
+                            ),
+                            models.FieldCondition(
+                                key="likes", match=models.MatchValue(value=True)
+                            ),
+                        ]
+                    ),
+                )
+            ),
+            models.HasIdCondition(has_id=[1]),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/rust.md
new file mode 100644
index 000000000..a7387ff0e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/rust.md
@@ -0,0 +1,19 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
+            NestedCondition {
+                key: "diet".to_string(),
+                filter: Some(Filter::must([
+                    Condition::matches("food", "meat".to_string()),
+                    Condition::matches("likes", true),
+                ])),
+            }
+            .into(),
+            Condition::has_id([1]),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/typescript.md
new file mode 100644
index 000000000..2bd09955f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause-and-has-id/typescript.md
@@ -0,0 +1,28 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        nested: {
+          key: "diet",
+          filter: {
+            must: [
+              {
+                key: "food",
+                match: { value: "meat" },
+              },
+              {
+                key: "likes",
+                match: { value: true },
+              },
+            ],
+          },
+        },
+      },
+      {
+        has_id: [1],
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/_description.md
new file mode 100644
index 000000000..764cd81ab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a POST request that filters through a collection of points based on nested conditions. It showcases how to filter points based on specific criteria within nested objects. In this case, the filter looks for points where a nested object with the key "diet" contains sub-objects that match the conditions specified for "food" and "likes". The snippet illustrates the concept of nested object filters, enabling the querying of arrays of objects independently.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/csharp.md
new file mode 100644
index 000000000..496818b2f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: Nested("diet", MatchKeyword("food", "meat") & Match("likes", true))
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/go.md
new file mode 100644
index 000000000..9fb1c3f32
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewNestedFilter("diet", &qdrant.Filter{
+				Must: []*qdrant.Condition{
+					qdrant.NewMatch("food", "meat"),
+					qdrant.NewMatchBool("likes", true),
+				},
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/http.md
new file mode 100644
index 000000000..366c09730
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/http.md
@@ -0,0 +1,28 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [{
+            "nested": {
+                "key": "diet",
+                "filter":{
+                    "must": [
+                        {
+                            "key": "food",
+                            "match": {
+                                "value": "meat"
+                            }
+                        },
+                        {
+                            "key": "likes",
+                            "match": {
+                                "value": true
+                            }
+                        }
+                    ]
+                }
+            }
+        }]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/java.md
new file mode 100644
index 000000000..477e37de9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/java.md
@@ -0,0 +1,28 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.match;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.ConditionFactory.nested;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMust(
+                        nested(
+                            "diet",
+                            Filter.newBuilder()
+                                .addAllMust(
+                                    List.of(
+                                        matchKeyword("food", "meat"), match("likes", true)))
+                                .build()))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/python.md
new file mode 100644
index 000000000..8bf003035
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/python.md
@@ -0,0 +1,24 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.NestedCondition(
+                nested=models.Nested(
+                    key="diet",
+                    filter=models.Filter(
+                        must=[
+                            models.FieldCondition(
+                                key="food", match=models.MatchValue(value="meat")
+                            ),
+                            models.FieldCondition(
+                                key="likes", match=models.MatchValue(value=True)
+                            ),
+                        ]
+                    ),
+                )
+            )
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/rust.md
new file mode 100644
index 000000000..e20947b11
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/rust.md
@@ -0,0 +1,16 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, NestedCondition, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([NestedCondition {
+            key: "diet".to_string(),
+            filter: Some(Filter::must([
+                Condition::matches("food", "meat".to_string()),
+                Condition::matches("likes", true),
+            ])),
+        }
+        .into()])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/typescript.md
new file mode 100644
index 000000000..7ea4f8547
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-filter-with-nested-clause/typescript.md
@@ -0,0 +1,25 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        nested: {
+          key: "diet",
+          filter: {
+            must: [
+              {
+                key: "food",
+                match: { value: "meat" },
+              },
+              {
+                key: "likes",
+                match: { value: true },
+              },
+            ],
+          },
+        },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/_description.md
new file mode 100644
index 000000000..5605c5391
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a query that filters data based on specific IDs. By providing a list of IDs, the query filters out results that do not match these specific IDs. This type of filtering can be beneficial when there is a need to exclude certain data points or focus the search on a predefined set of IDs.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/csharp.md
new file mode 100644
index 000000000..5631cc618
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/csharp.md
@@ -0,0 +1,8 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(collectionName: "{collection_name}", filter: HasId([1, 3, 5, 7, 9, 11]));
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/go.md
new file mode 100644
index 000000000..847e2116a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/go.md
@@ -0,0 +1,28 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewHasID(
+				qdrant.NewIDNum(1),
+				qdrant.NewIDNum(3),
+				qdrant.NewIDNum(5),
+				qdrant.NewIDNum(7),
+				qdrant.NewIDNum(9),
+				qdrant.NewIDNum(11),
+			),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/http.md
new file mode 100644
index 000000000..05ed82a3d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            { "has_id": [1,3,5,7,9,11] }
+        ]
+    }
+    ...
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/java.md
new file mode 100644
index 000000000..7db1a57c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/java.md
@@ -0,0 +1,20 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.hasId;
+import static io.qdrant.client.PointIdFactory.id;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMust(hasId(List.of(id(1), id(3), id(5), id(7), id(9), id(11))))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/python.md
new file mode 100644
index 000000000..c9c6415c5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/python.md
@@ -0,0 +1,10 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.HasIdCondition(has_id=[1, 3, 5, 7, 9, 11]),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/rust.md
new file mode 100644
index 000000000..f6de7403b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+    
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}")
+            .filter(Filter::must([Condition::has_id([1, 3, 5, 7, 9, 11])])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/typescript.md
new file mode 100644
index 000000000..01095a546
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-has-id-filter/typescript.md
@@ -0,0 +1,11 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        has_id: [1, 3, 5, 7, 9, 11],
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/_description.md
new file mode 100644
index 000000000..9062948d4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates a way to combine multiple clauses to filter data. In this example, the code shows how to filter data based on a specific city value (in this case, "London") while excluding another specific value (in this case, the color "red"). The specified clauses work together in the filter to refine the results accordingly.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/csharp.md
new file mode 100644
index 000000000..80eb3e911
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("city", "London") & !MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/go.md
new file mode 100644
index 000000000..cdb1be376
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/go.md
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("city", "London"),
+		},
+		MustNot: []*qdrant.Condition{
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/http.md
new file mode 100644
index 000000000..d9728b3d8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/http.md
@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            { "key": "city", "match": { "value": "London" } }
+        ],
+        "must_not": [
+            { "key": "color", "match": { "value": "red" } }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/java.md
new file mode 100644
index 000000000..321ef684f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/java.md
@@ -0,0 +1,18 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMust(matchKeyword("city", "London"))
+                    .addMustNot(matchKeyword("color", "red"))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/python.md
new file mode 100644
index 000000000..84468e9fe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/python.md
@@ -0,0 +1,13 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
+        ],
+        must_not=[
+            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/rust.md
new file mode 100644
index 000000000..ee569ae8c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter {
+            must: vec![Condition::matches("city", "London".to_string())],
+            must_not: vec![Condition::matches("color", "red".to_string())],
+            ..Default::default()
+        }),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/typescript.md
new file mode 100644
index 000000000..234f5e4f9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-multiple-clauses-combination/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "city",
+        match: { value: "London" },
+      },
+    ],
+    must_not: [
+      {
+        key: "color",
+        match: { value: "red" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/_description.md
new file mode 100644
index 000000000..474d75d4b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/_description.md
@@ -0,0 +1 @@
+This code snippet shows an example of filtering scroll points based on specified conditions using the "must" filter logic. In this case, the code filters scroll points where the city is "London" and the color is "red".
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/csharp.md
new file mode 100644
index 000000000..103207fca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+// & operator combines two conditions in an AND conjunction(must)
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("city", "London") & MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/go.md
new file mode 100644
index 000000000..143ea743f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Must: []*qdrant.Condition{
+			qdrant.NewMatch("city", "London"),
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/http.md
new file mode 100644
index 000000000..ace25c20d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must": [
+            { "key": "city", "match": { "value": "London" } },
+            { "key": "color", "match": { "value": "red" } }
+        ]
+    }
+    ...
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/java.md
new file mode 100644
index 000000000..960c99dcb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/java.md
@@ -0,0 +1,25 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addAllMust(
+                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/python.md
new file mode 100644
index 000000000..79992437c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/python.md
@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="city",
+                match=models.MatchValue(value="London"),
+            ),
+            models.FieldCondition(
+                key="color",
+                match=models.MatchValue(value="red"),
+            ),
+        ]
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/rust.md
new file mode 100644
index 000000000..b14f5c4ac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must([
+            Condition::matches("city", "london".to_string()),
+            Condition::matches("color", "red".to_string()),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/typescript.md
new file mode 100644
index 000000000..c903b4ed6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-filter/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.scroll("{collection_name}", {
+  filter: {
+    must: [
+      {
+        key: "city",
+        match: { value: "London" },
+      },
+      {
+        key: "color",
+        match: { value: "red" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/_description.md
new file mode 100644
index 000000000..a06cae64a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to use a filter to exclude certain points when scrolling through a collection. In this case, points with the key "city" set to "London" and the key "color" set to "red" are excluded from the results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/csharp.md
new file mode 100644
index 000000000..6143db12c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+// The ! operator negates the condition(must not)
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: !(MatchKeyword("city", "London") & MatchKeyword("color", "red"))
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/go.md
new file mode 100644
index 000000000..bf3f6bf0b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		MustNot: []*qdrant.Condition{
+			qdrant.NewMatch("city", "London"),
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/http.md
new file mode 100644
index 000000000..0b87ab225
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must_not": [
+            { "key": "city", "match": { "value": "London" } },
+            { "key": "color", "match": { "value": "red" } }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/java.md
new file mode 100644
index 000000000..77173db30
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/java.md
@@ -0,0 +1,20 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addAllMustNot(
+                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/python.md
new file mode 100644
index 000000000..5b3139b3f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/python.md
@@ -0,0 +1,11 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must_not=[
+            models.FieldCondition(key="city", match=models.MatchValue(value="London")),
+            models.FieldCondition(key="color", match=models.MatchValue(value="red")),
+        ]
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/rust.md
new file mode 100644
index 000000000..ee38c3852
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([
+            Condition::matches("city", "london".to_string()),
+            Condition::matches("color", "red".to_string()),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/typescript.md
new file mode 100644
index 000000000..d37e73e7c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-must-not-filter/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must_not: [
+      {
+        key: "city",
+        match: { value: "London" },
+      },
+      {
+        key: "color",
+        match: { value: "red" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/_description.md
new file mode 100644
index 000000000..dd005ad36
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to perform a POST request to filter items based on specific criteria. The filter specifies that the collection should not include points where the city is "London" and the color is "red". The conditions are nested within each other to create complex filtering logic.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/csharp.md
new file mode 100644
index 000000000..24252ca29
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: new Filter { MustNot = { MatchKeyword("city", "London") & MatchKeyword("color", "red") } }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/go.md
new file mode 100644
index 000000000..9e22d6df8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/go.md
@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		MustNot: []*qdrant.Condition{
+			qdrant.NewFilterAsCondition(&qdrant.Filter{
+				Must: []*qdrant.Condition{
+					qdrant.NewMatch("city", "London"),
+					qdrant.NewMatch("color", "red"),
+				},
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/http.md
new file mode 100644
index 000000000..ab7bb03ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/http.md
@@ -0,0 +1,15 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "must_not": [
+            {
+                "must": [
+                    { "key": "city", "match": { "value": "London" } },
+                    { "key": "color", "match": { "value": "red" } }
+                ]
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/java.md
new file mode 100644
index 000000000..4ec4275ce
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/java.md
@@ -0,0 +1,27 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.ConditionFactory.filter;
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addMustNot(
+                        filter(
+                            Filter.newBuilder()
+                                .addAllMust(
+                                    List.of(
+                                        matchKeyword("city", "London"),
+                                        matchKeyword("color", "red")))
+                                .build()))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/python.md
new file mode 100644
index 000000000..fc263ec86
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/python.md
@@ -0,0 +1,19 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        must_not=[
+            models.Filter(
+                must=[
+                    models.FieldCondition(
+                        key="city", match=models.MatchValue(value="London")
+                    ),
+                    models.FieldCondition(
+                        key="color", match=models.MatchValue(value="red")
+                    ),
+                ],
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/rust.md
new file mode 100644
index 000000000..42fdb65dc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::must_not([Filter::must(
+            [
+                Condition::matches("city", "London".to_string()),
+                Condition::matches("color", "red".to_string()),
+            ],
+        )
+        .into()])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/typescript.md
new file mode 100644
index 000000000..d92032166
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-nested-clauses-filter/typescript.md
@@ -0,0 +1,20 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    must_not: [
+      {
+        must: [
+          {
+            key: "city",
+            match: { value: "London" },
+          },
+          {
+            key: "color",
+            match: { value: "red" },
+          },
+        ],
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/_description.md
new file mode 100644
index 000000000..71ef21257
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to utilize the `order_by` key parameter to define the sorting criteria. Additionally, it showcases the inclusion of supplementary fields like `direction` to specify the sorting order and `start_from` to set a specific starting point for ordering.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/csharp.md
new file mode 100644
index 000000000..ca7d58107
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/csharp.md
@@ -0,0 +1,10 @@
+```csharp
+using Qdrant.Client.Grpc;
+
+new OrderBy
+{
+ Key = "timestamp",
+ Direction = Direction.Desc,
+ StartFrom = 123
+};
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/go.md
new file mode 100644
index 000000000..cba0ee580
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/go.md
@@ -0,0 +1,9 @@
+```go
+import "github.com/qdrant/go-client/qdrant"
+
+qdrant.OrderBy{
+	Key:       "timestamp",
+	Direction: qdrant.Direction_Desc.Enum(),
+	StartFrom: qdrant.NewStartFromInt(123),
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/http.md
new file mode 100644
index 000000000..1f5f7d4fe
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/http.md
@@ -0,0 +1,7 @@
+```http
+"order_by": {
+    "key": "timestamp",
+    "direction": "desc" // default is "asc"
+    "start_from": 123, // start from this value
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/java.md
new file mode 100644
index 000000000..083bb7497
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/java.md
@@ -0,0 +1,13 @@
+```java
+import io.qdrant.client.grpc.Points.Direction;
+import io.qdrant.client.grpc.Points.OrderBy;
+import io.qdrant.client.grpc.Points.StartFrom;
+
+OrderBy.newBuilder()
+  .setKey("timestamp")
+  .setDirection(Direction.Desc)
+  .setStartFrom(StartFrom.newBuilder()
+    .setInteger(123)
+    .build())
+  .build();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/python.md
new file mode 100644
index 000000000..0c1739a2e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/python.md
@@ -0,0 +1,7 @@
+```python
+order_by=models.OrderBy(
+    key="timestamp",
+    direction="desc",  # default is "asc"
+    start_from=123,  # start from this value
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/rust.md
new file mode 100644
index 000000000..bd672122f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/rust.md
@@ -0,0 +1,8 @@
+```rust
+use qdrant_client::qdrant::{start_from::Value, Direction, OrderByBuilder};
+
+OrderByBuilder::new("timestamp")
+    .direction(Direction::Desc.into())
+    .start_from(Value::Integer(123))
+    .build();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/typescript.md
new file mode 100644
index 000000000..cf72406f5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-advanced/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+order_by: {
+    key: "timestamp",
+    direction: "desc", // default is "asc"
+    start_from: 123, // start from this value
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/_description.md
new file mode 100644
index 000000000..cbd391f78
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/_description.md
@@ -0,0 +1 @@
+Sort your collection points by a custom payload key when using the scroll API. This feature enables you to order and retrieve the points based on a specific payload key, in this case, the `"timestamp"` field. Just keep in mind that for this to work efficiently, Qdrant needs a payload index supporting range filtering conditions.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/csharp.md
new file mode 100644
index 000000000..3faf067db
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/csharp.md
@@ -0,0 +1,3 @@
+```csharp
+await client.ScrollAsync("{collection_name}", limit: 15, orderBy: "timestamp");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/go.md
new file mode 100644
index 000000000..880bf7b35
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/go.md
@@ -0,0 +1,20 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Limit:          qdrant.PtrOf(uint32(15)),
+	OrderBy: &qdrant.OrderBy{
+		Key: "timestamp",
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/http.md
new file mode 100644
index 000000000..2ca22002d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/http.md
@@ -0,0 +1,7 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "limit": 15,
+    "order_by": "timestamp", // <-- this!
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/java.md
new file mode 100644
index 000000000..9c462fe1b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/java.md
@@ -0,0 +1,10 @@
+```java
+import io.qdrant.client.grpc.Points.OrderBy;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+
+client.scrollAsync(ScrollPoints.newBuilder()
+  .setCollectionName("{collection_name}")
+  .setLimit(15)
+  .setOrderBy(OrderBy.newBuilder().setKey("timestamp").build())
+  .build()).get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/python.md
new file mode 100644
index 000000000..5bf5a14ea
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/python.md
@@ -0,0 +1,7 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    limit=15,
+    order_by="timestamp", # <-- this!
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/rust.md
new file mode 100644
index 000000000..9cb556d8e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::{OrderByBuilder, ScrollPointsBuilder};
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}")
+            .limit(15)
+            .order_by(OrderByBuilder::new("timestamp")),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/typescript.md
new file mode 100644
index 000000000..7f2def136
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-order-by-simple/typescript.md
@@ -0,0 +1,6 @@
+```typescript
+client.scroll("{collection_name}", {
+  limit: 15,
+  order_by: "timestamp", // <-- this!
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/_description.md
new file mode 100644
index 000000000..9ebdadd5e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/_description.md
@@ -0,0 +1 @@
+This code snippet showcases how to use a filter with multiple conditions for scrolling through points in a collection. In this case, the conditions specified in the filter are that the "city" should be "London" and the "color" should be "red". The usage of "should" indicates that any point meeting at least one of these conditions will be included in the results.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/csharp.md
new file mode 100644
index 000000000..343809a73
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+// | operator combines two conditions in an OR disjunction(should)
+await client.ScrollAsync(
+	collectionName: "{collection_name}",
+	filter: MatchKeyword("city", "London") | MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/go.md
new file mode 100644
index 000000000..2c5ea26ac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/go.md
@@ -0,0 +1,22 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Scroll(context.Background(), &qdrant.ScrollPoints{
+	CollectionName: "{collection_name}",
+	Filter: &qdrant.Filter{
+		Should: []*qdrant.Condition{
+			qdrant.NewMatch("city", "London"),
+			qdrant.NewMatch("color", "red"),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/http.md
new file mode 100644
index 000000000..2dc623099
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/http.md
@@ -0,0 +1,11 @@
+```http
+POST /collections/{collection_name}/points/scroll
+{
+    "filter": {
+        "should": [
+            { "key": "city", "match": { "value": "London" } },
+            { "key": "color", "match": { "value": "red" } }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/java.md
new file mode 100644
index 000000000..2b79d9014
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/java.md
@@ -0,0 +1,19 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.grpc.Points.ScrollPoints;
+import java.util.List;
+
+client
+    .scrollAsync(
+        ScrollPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setFilter(
+                Filter.newBuilder()
+                    .addAllShould(
+                        List.of(matchKeyword("city", "London"), matchKeyword("color", "red")))
+                    .build())
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/python.md
new file mode 100644
index 000000000..94ecb9453
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/python.md
@@ -0,0 +1,17 @@
+```python
+client.scroll(
+    collection_name="{collection_name}",
+    scroll_filter=models.Filter(
+        should=[
+            models.FieldCondition(
+                key="city",
+                match=models.MatchValue(value="London"),
+            ),
+            models.FieldCondition(
+                key="color",
+                match=models.MatchValue(value="red"),
+            ),
+        ]
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/rust.md
new file mode 100644
index 000000000..7cdf7cd23
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/rust.md
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, ScrollPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .scroll(
+        ScrollPointsBuilder::new("{collection_name}").filter(Filter::should([
+            Condition::matches("city", "london".to_string()),
+            Condition::matches("color", "red".to_string()),
+        ])),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/typescript.md
new file mode 100644
index 000000000..ccd01ed5f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/scroll-points/with-should-filter/typescript.md
@@ -0,0 +1,16 @@
+```typescript
+client.scroll("{collection_name}", {
+  filter: {
+    should: [
+      {
+        key: "city",
+        match: { value: "London" },
+      },
+      {
+        key: "color",
+        match: { value: "red" },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/_description.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/_description.md
new file mode 100644
index 000000000..c3148d7c6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/_description.md
@@ -0,0 +1 @@
+Set the payload for points in a collection by applying a filter based on the specified properties. In this case, the code will set the payload with "property1" and "property2" values for points where the value of the "color" property is "red" within the specified collection. This approach allows for targeted modifications without needing to know the specific point ids.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/csharp.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/csharp.md
new file mode 100644
index 000000000..2815fc727
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/csharp.md
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.SetPayloadAsync(
+    collectionName: "{collection_name}",
+    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
+    filter: MatchKeyword("color", "red")
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/go.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/go.md
new file mode 100644
index 000000000..535153aed
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/go.md
@@ -0,0 +1,23 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.SetPayload(context.Background(), &qdrant.SetPayloadPoints{
+    CollectionName: "{collection_name}",
+    Payload: qdrant.NewValueMap(
+        map[string]any{"property1": "string", "property2": "string"}),
+    PointsSelector: qdrant.NewPointsSelectorFilter(&qdrant.Filter{
+        Must: []*qdrant.Condition{
+            qdrant.NewMatch("color", "red"),
+        },
+    }),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/http.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/http.md
new file mode 100644
index 000000000..87bc38524
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/http.md
@@ -0,0 +1,19 @@
+```http
+POST /collections/{collection_name}/points/payload
+{
+    "payload": {
+        "property1": "string",
+        "property2": "string"
+    },
+    "filter": {
+        "must": [
+            {
+                "key": "color",
+                "match": {
+                    "value": "red"
+                }
+            }
+        ]
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/java.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/java.md
new file mode 100644
index 000000000..2df7082f2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/java.md
@@ -0,0 +1,16 @@
+```java
+import java.util.Map;
+
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.ValueFactory.value;
+
+client
+    .setPayloadAsync(
+        "{collection_name}",
+        Map.of("property1", value("string"), "property2", value("string")),
+        Filter.newBuilder().addMust(matchKeyword("color", "red")).build(),
+        true,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/python.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/python.md
new file mode 100644
index 000000000..4dc9b02ca
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/python.md
@@ -0,0 +1,17 @@
+```python
+client.set_payload(
+    collection_name="{collection_name}",
+    payload={
+        "property1": "string",
+        "property2": "string",
+    },
+    points=models.Filter(
+        must=[
+            models.FieldCondition(
+                key="color",
+                match=models.MatchValue(value="red"),
+            ),
+        ],
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/rust.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/rust.md
new file mode 100644
index 000000000..47bff1c95
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/rust.md
@@ -0,0 +1,23 @@
+```rust
+use qdrant_client::qdrant::{Condition, Filter, SetPayloadPointsBuilder};
+use qdrant_client::Payload;
+use serde_json::json;
+
+client
+    .set_payload(
+        SetPayloadPointsBuilder::new(
+            "{collection_name}",
+            Payload::try_from(json!({
+                "property1": "string",
+                "property2": "string",
+            }))
+            .unwrap(),
+        )
+        .points_selector(Filter::must([Condition::matches(
+            "color",
+            "red".to_string(),
+        )]))
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/typescript.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/typescript.md
new file mode 100644
index 000000000..5c91a4196
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-filter/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+client.setPayload("{collection_name}", {
+  payload: {
+    property1: "string",
+    property2: "string",
+  },
+  filter: {
+    must: [
+      {
+        key: "color",
+        match: {
+          value: "red",
+        },
+      },
+    ],
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/_description.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/_description.md
new file mode 100644
index 000000000..61297815d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates how to set a new value 'qux' for the nested property within the payload of a specified key named 'property1'.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/http.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/http.md
new file mode 100644
index 000000000..25a9c93b8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-nested-key/http.md
@@ -0,0 +1,10 @@
+```http
+POST /collections/{collection_name}/points/payload
+{
+    "payload": {
+        "nested_property": "qux",
+    },
+    "key": "property1",
+    "points": [1]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/_description.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/_description.md
new file mode 100644
index 000000000..f4cc9529a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/_description.md
@@ -0,0 +1 @@
+Update the specified properties with the provided values for the selected points within a collection. This code snippet demonstrates setting the payload data for specific points identified by their unique IDs in the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/csharp.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/csharp.md
new file mode 100644
index 000000000..097494065
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/csharp.md
@@ -0,0 +1,12 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.SetPayloadAsync(
+    collectionName: "{collection_name}",
+    payload: new Dictionary<string, Value> { { "property1", "string" }, { "property2", "string" } },
+    ids: new ulong[] { 0, 3, 10 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/go.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/go.md
new file mode 100644
index 000000000..f9535fb6b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/go.md
@@ -0,0 +1,21 @@
+```go
+import (
+    "context"
+
+    "github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host: "localhost",
+    Port: 6334,
+})
+
+client.SetPayload(context.Background(), &qdrant.SetPayloadPoints{
+    CollectionName: "{collection_name}",
+    Payload: qdrant.NewValueMap(
+        map[string]any{"property1": "string", "property2": "string"}),
+    PointsSelector: qdrant.NewPointsSelector(
+        qdrant.NewIDNum(0),
+        qdrant.NewIDNum(3)),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/http.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/http.md
new file mode 100644
index 000000000..0db40abc5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/http.md
@@ -0,0 +1,12 @@
+```http
+POST /collections/{collection_name}/points/payload
+{
+    "payload": {
+        "property1": "string",
+        "property2": "string"
+    },
+    "points": [
+        0, 3, 100
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/java.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/java.md
new file mode 100644
index 000000000..ac9aff9c1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/java.md
@@ -0,0 +1,17 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+
+client
+    .setPayloadAsync(
+        "{collection_name}",
+        Map.of("property1", value("string"), "property2", value("string")),
+        List.of(id(0), id(3), id(10)),
+        true,
+        null,
+        null)
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/python.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/python.md
new file mode 100644
index 000000000..8141db127
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/python.md
@@ -0,0 +1,10 @@
+```python
+client.set_payload(
+    collection_name="{collection_name}",
+    payload={
+        "property1": "string",
+        "property2": "string",
+    },
+    points=[0, 3, 10],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/rust.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/rust.md
new file mode 100644
index 000000000..dd558eb64
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/rust.md
@@ -0,0 +1,24 @@
+```rust
+use qdrant_client::qdrant::{
+    PointsIdsList, SetPayloadPointsBuilder,
+};
+use qdrant_client::Payload,;
+use serde_json::json;
+
+client
+    .set_payload(
+        SetPayloadPointsBuilder::new(
+            "{collection_name}",
+            Payload::try_from(json!({
+                "property1": "string",
+                "property2": "string",
+            }))
+            .unwrap(),
+        )
+        .points_selector(PointsIdsList {
+            ids: vec![0.into(), 3.into(), 10.into()],
+        })
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/typescript.md b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/typescript.md
new file mode 100644
index 000000000..198c2c448
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/set-payload/by-point-id/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+client.setPayload("{collection_name}", {
+  payload: {
+    property1: "string",
+    property2: "string",
+  },
+  points: [0, 3, 10],
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/_description.md
new file mode 100644
index 000000000..1bc860d8a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/_description.md
@@ -0,0 +1 @@
+This code snippet allows you to create a snapshot for a specific collection. It mentions that when working with a distributed deployment, snapshots should be created for each node individually as a snapshot will only include the data from the node it was created on.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/csharp.md
new file mode 100644
index 000000000..2b3c7a77a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateSnapshotAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/go.md
new file mode 100644
index 000000000..84283412c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateSnapshot(context.Background(), "{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/http.md
new file mode 100644
index 000000000..526534db0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+POST /collections/{collection_name}/snapshots
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/java.md
new file mode 100644
index 000000000..557df36c3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+      new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createSnapshotAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/python.md
new file mode 100644
index 000000000..8ef0aa19d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_snapshot(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/rust.md
new file mode 100644
index 000000000..9072ae65b
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_snapshot("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/typescript.md
new file mode 100644
index 000000000..9a6e72840
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-collection-snapshot/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createSnapshot("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/_description.md
new file mode 100644
index 000000000..e88eec4ec
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/_description.md
@@ -0,0 +1 @@
+This code creates a full storage snapshot for the specified category.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/csharp.md
new file mode 100644
index 000000000..3e13e4f95
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateFullSnapshotAsync();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/go.md
new file mode 100644
index 000000000..e892e8bd0
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateFullSnapshot(context.Background())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/http.md
new file mode 100644
index 000000000..045fb4353
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+POST /snapshots
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/java.md
new file mode 100644
index 000000000..2237b916a
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createFullSnapshotAsync().get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/python.md
new file mode 100644
index 000000000..a5fa6eee6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_full_snapshot()
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/rust.md
new file mode 100644
index 000000000..85c458cdf
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.create_full_snapshot().await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/typescript.md
new file mode 100644
index 000000000..be7b30583
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/create-full-snapshot/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createFullSnapshot();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/_description.md
new file mode 100644
index 000000000..c8b8dc74e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/_description.md
@@ -0,0 +1 @@
+This code snippet deletes a specific snapshot associated with a collection. The `DELETE` method is used to initiate the deletion process for the snapshot with the specified `snapshot_name` within the `collection_name`.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/csharp.md
new file mode 100644
index 000000000..5dbfb000e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeleteSnapshotAsync(collectionName: "{collection_name}", snapshotName: "{snapshot_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/go.md
new file mode 100644
index 000000000..33931bcad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.DeleteSnapshot(context.Background(), "{collection_name}", "{snapshot_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/http.md
new file mode 100644
index 000000000..6c1674e23
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+DELETE /collections/{collection_name}/snapshots/{snapshot_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/java.md
new file mode 100644
index 000000000..509e22cb5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.deleteSnapshotAsync("{collection_name}", "{snapshot_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/python.md
new file mode 100644
index 000000000..2811cca3e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/python.md
@@ -0,0 +1,9 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.delete_snapshot(
+    collection_name="{collection_name}", snapshot_name="{snapshot_name}"
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/rust.md
new file mode 100644
index 000000000..be5d7e9d7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/rust.md
@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::qdrant::DeleteSnapshotRequestBuilder;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .delete_snapshot(DeleteSnapshotRequestBuilder::new(
+        "{collection_name}",
+        "{snapshot_name}",
+    ))
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/typescript.md
new file mode 100644
index 000000000..590977244
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-collection-snapshot/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.deleteSnapshot("{collection_name}", "{snapshot_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/_description.md
new file mode 100644
index 000000000..9750509c5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/_description.md
@@ -0,0 +1 @@
+This code snippet represents functionality to delete a full storage snapshot. It allows users to send a request to delete a specific snapshot by its name. This operation can be used to manage storage snapshots efficiently.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/csharp.md
new file mode 100644
index 000000000..841209fda
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.DeleteFullSnapshotAsync("{snapshot_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/go.md
new file mode 100644
index 000000000..2865bd0ab
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.DeleteFullSnapshot(context.Background(), "{snapshot_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/http.md
new file mode 100644
index 000000000..c3d0cac86
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+DELETE /snapshots/{snapshot_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/java.md
new file mode 100644
index 000000000..2c416cb97
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.deleteFullSnapshotAsync("{snapshot_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/python.md
new file mode 100644
index 000000000..e7a2b4636
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.delete_full_snapshot(snapshot_name="{snapshot_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/rust.md
new file mode 100644
index 000000000..a190d2fbd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.delete_full_snapshot("{snapshot_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/typescript.md
new file mode 100644
index 000000000..3fbfb81d6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/delete-full-snapshot/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.deleteFullSnapshot("{snapshot_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/_description.md
new file mode 100644
index 000000000..8e248c5bd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/_description.md
@@ -0,0 +1 @@
+Retrieve a specific snapshot from a collection by its name using the available REST API. This code snippet allows downloading the snapshot as a file once it is fetched from the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/http.md
new file mode 100644
index 000000000..8f00df4b5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections/{collection_name}/snapshots/{snapshot_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/shell.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/shell.md
new file mode 100644
index 000000000..4e6a79b77
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-collection-snapshot/shell.md
@@ -0,0 +1,5 @@
+```shell
+curl 'http://{qdrant-url}:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.snapshot' \
+    -H 'api-key: ********' \
+    --output 'filename.snapshot'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/_description.md
new file mode 100644
index 000000000..5c379af80
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/_description.md
@@ -0,0 +1 @@
+This code allows downloading the full storage snapshot specified by its name. Please note that this functionality is currently accessible only through the REST API.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/http.md
new file mode 100644
index 000000000..5e41c5381
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/download-full-snapshot/http.md
@@ -0,0 +1,3 @@
+```http
+GET /snapshots/{snapshot_name}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/_description.md
new file mode 100644
index 000000000..c922433d3
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/_description.md
@@ -0,0 +1 @@
+This code snippet is used to list snapshots for a specific collection. It is designed to provide a way to retrieve a collection's snapshots for reference or further actions within an application.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/csharp.md
new file mode 100644
index 000000000..934409c22
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ListSnapshotsAsync("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/go.md
new file mode 100644
index 000000000..7e17e17ac
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.ListSnapshots(context.Background(), "{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/http.md
new file mode 100644
index 000000000..7764a30a7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/http.md
@@ -0,0 +1,3 @@
+```http
+GET /collections/{collection_name}/snapshots
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/java.md
new file mode 100644
index 000000000..158affaec
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.listSnapshotAsync("{collection_name}").get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/python.md
new file mode 100644
index 000000000..ae2dae492
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.list_snapshots(collection_name="{collection_name}")
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/rust.md
new file mode 100644
index 000000000..03280ddf7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.list_snapshots("{collection_name}").await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/typescript.md
new file mode 100644
index 000000000..4dbda6cf7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-collection-snapshots/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.listSnapshots("{collection_name}");
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/_description.md
new file mode 100644
index 000000000..6e7cf4afd
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/_description.md
@@ -0,0 +1 @@
+This code snippet is used to list all the full storage snapshots available.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/csharp.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/csharp.md
new file mode 100644
index 000000000..712e89d43
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/csharp.md
@@ -0,0 +1,7 @@
+```csharp
+using Qdrant.Client;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.ListFullSnapshotsAsync();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/go.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/go.md
new file mode 100644
index 000000000..9247b9c16
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/go.md
@@ -0,0 +1,14 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.ListFullSnapshots(context.Background())
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/http.md
new file mode 100644
index 000000000..434dd1eb8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/http.md
@@ -0,0 +1,3 @@
+```http
+GET /snapshots
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/java.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/java.md
new file mode 100644
index 000000000..9eb5f6d48
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/java.md
@@ -0,0 +1,9 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.listFullSnapshotAsync().get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/python.md
new file mode 100644
index 000000000..2d6060484
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/python.md
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient("localhost", port=6333)
+
+client.list_full_snapshots()
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/rust.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/rust.md
new file mode 100644
index 000000000..32daf84e7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/rust.md
@@ -0,0 +1,7 @@
+```rust
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client.list_full_snapshots().await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/typescript.md
new file mode 100644
index 000000000..d55c9bf0f
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/list-full-snapshots/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.listFullSnapshots();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/_description.md
new file mode 100644
index 000000000..2ba24fbc9
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/_description.md
@@ -0,0 +1 @@
+Recover a collection snapshot by providing a URL pointing to the location of the snapshot file. This method allows you to recover a collection snapshot from a URL or a local file stored on the node. If the specified collection does not exist, a new collection will be created upon recovery.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/http.md
new file mode 100644
index 000000000..8239f53c5
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/http.md
@@ -0,0 +1,6 @@
+```http
+PUT /collections/{collection_name}/snapshots/recover
+{
+  "location": "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot"
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/python.md
new file mode 100644
index 000000000..f4746fdc4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/python.md
@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient
+
+client = QdrantClient(url="http://qdrant-node-2:6333")
+
+client.recover_snapshot(
+    "{collection_name}",
+    "http://qdrant-node-1:6333/collections/collection_name/snapshots/snapshot-2022-10-10.shapshot",
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/typescript.md
new file mode 100644
index 000000000..0a3cece0e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-collection-snapshot-from-url/typescript.md
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.recoverSnapshot("{collection_name}", {
+  location: "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/_description.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/_description.md
new file mode 100644
index 000000000..410e71014
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/_description.md
@@ -0,0 +1,7 @@
+When recovering a snapshot, you can set a priority to determine how conflicts between snapshot data and existing data are handled. There are three priority options available:
+
+- `replica` (default): Prioritizes existing data over snapshot data.
+- `snapshot`: Prioritizes snapshot data over existing data.
+- `no_sync`: Restores snapshot without additional synchronization, useful for manual shard management.
+
+By setting the priority to `snapshot`, all data from the snapshot will be recovered onto the cluster. Using `replica` may result in an empty collection if there was no existing data in the cluster. `no_sync` is for specialized cases involving manual shard management and should be used carefully to avoid cluster issues. The priority setting is essential for controlling the outcome of snapshot recoveries.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/bash.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/bash.md
new file mode 100644
index 000000000..0a7499f08
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/bash.md
@@ -0,0 +1,6 @@
+```bash
+curl -X POST 'http://qdrant-node-1:6333/collections/{collection_name}/snapshots/upload?priority=snapshot' \
+    -H 'api-key: ********' \
+    -H 'Content-Type:multipart/form-data' \
+    -F 'snapshot=@/path/to/snapshot-2022-10-10.shapshot'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/http.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/http.md
new file mode 100644
index 000000000..ae51a9ebc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/http.md
@@ -0,0 +1,7 @@
+```http
+PUT /collections/{collection_name}/snapshots/recover
+{
+  "location": "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
+  "priority": "snapshot"
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/python.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/python.md
new file mode 100644
index 000000000..c34ec08e7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/python.md
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://qdrant-node-2:6333")
+
+client.recover_snapshot(
+    "{collection_name}",
+    "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
+    priority=models.SnapshotPriority.SNAPSHOT,
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/typescript.md b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/typescript.md
new file mode 100644
index 000000000..0ba2d2859
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/snapshots/recover-snapshot-with-priority/typescript.md
@@ -0,0 +1,10 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.recoverSnapshot("{collection_name}", {
+  location: "http://qdrant-node-1:6333/collections/{collection_name}/snapshots/snapshot-2022-10-10.shapshot",
+  priority: "snapshot"
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/_description.md
new file mode 100644
index 000000000..9ed7f4238
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/_description.md
@@ -0,0 +1 @@
+This code snippet demonstrates updating HNSW index and quantization parameters for a collection, as well as for a specific vector within the collection called `my_vector`. The values like `m`, `ef_construct`, compression type, and quantization settings are adjusted for optimization.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/bash.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/bash.md
new file mode 100644
index 000000000..51c615207
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/bash.md
@@ -0,0 +1,31 @@
+```bash
+curl -X PATCH http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+        "my_vector": {
+            "hnsw_config": {
+                "m": 32,
+                "ef_construct": 123
+            },
+            "quantization_config": {
+                "product": {
+                    "compression": "x32",
+                    "always_ram": true
+                }
+            },
+            "on_disk": true
+        }
+    },
+    "hnsw_config": {
+        "ef_construct": 123
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "quantile": 0.8,
+            "always_ram": false
+        }
+    }
+}'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/csharp.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/csharp.md
new file mode 100644
index 000000000..bda7dbee4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/csharp.md
@@ -0,0 +1,33 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpdateCollectionAsync(
+	collectionName: "{collection_name}",
+	hnswConfig: new HnswConfigDiff { EfConstruct = 123 },
+	vectorsConfig: new VectorParamsDiffMap
+	{
+		Map =
+		{
+			{
+				"my_vector",
+				new VectorParamsDiff
+				{
+					HnswConfig = new HnswConfigDiff { M = 3, EfConstruct = 123 }
+				}
+			}
+		}
+	},
+	quantizationConfig: new QuantizationConfigDiff
+	{
+		Scalar = new ScalarQuantization
+		{
+			Type = QuantizationType.Int8,
+			Quantile = 0.8f,
+			AlwaysRam = true
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/go.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/go.md
new file mode 100644
index 000000000..5d0debc1e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/go.md
@@ -0,0 +1,31 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
+	CollectionName: "{collection_name}",
+	VectorsConfig: qdrant.NewVectorsConfigDiffMap(
+		map[string]*qdrant.VectorParamsDiff{
+			"my_vector": {
+				HnswConfig: &qdrant.HnswConfigDiff{
+					M:           qdrant.PtrOf(uint64(3)),
+					EfConstruct: qdrant.PtrOf(uint64(123)),
+				},
+			},
+		}),
+	QuantizationConfig: qdrant.NewQuantizationDiffScalar(
+		&qdrant.ScalarQuantization{
+			Type:      qdrant.QuantizationType_Int8,
+			Quantile:  qdrant.PtrOf(float32(0.8)),
+			AlwaysRam: qdrant.PtrOf(true),
+		}),
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/http.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/http.md
new file mode 100644
index 000000000..95ff5f064
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/http.md
@@ -0,0 +1,30 @@
+```http
+PATCH /collections/{collection_name}
+{
+    "vectors": {
+        "my_vector": {
+            "hnsw_config": {
+                "m": 32,
+                "ef_construct": 123
+            },
+            "quantization_config": {
+                "product": {
+                    "compression": "x32",
+                    "always_ram": true
+                }
+            },
+            "on_disk": true
+        }
+    },
+    "hnsw_config": {
+        "ef_construct": 123
+    },
+    "quantization_config": {
+        "scalar": {
+            "type": "int8",
+            "quantile": 0.8,
+            "always_ram": false
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/java.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/java.md
new file mode 100644
index 000000000..6d41979c4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/java.md
@@ -0,0 +1,39 @@
+```java
+import io.qdrant.client.grpc.Collections.HnswConfigDiff;
+import io.qdrant.client.grpc.Collections.QuantizationConfigDiff;
+import io.qdrant.client.grpc.Collections.QuantizationType;
+import io.qdrant.client.grpc.Collections.ScalarQuantization;
+import io.qdrant.client.grpc.Collections.UpdateCollection;
+import io.qdrant.client.grpc.Collections.VectorParamsDiff;
+import io.qdrant.client.grpc.Collections.VectorParamsDiffMap;
+import io.qdrant.client.grpc.Collections.VectorsConfigDiff;
+
+client
+    .updateCollectionAsync(
+        UpdateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setHnswConfig(HnswConfigDiff.newBuilder().setEfConstruct(123).build())
+            .setVectorsConfig(
+                VectorsConfigDiff.newBuilder()
+                    .setParamsMap(
+                        VectorParamsDiffMap.newBuilder()
+                            .putMap(
+                                "my_vector",
+                                VectorParamsDiff.newBuilder()
+                                    .setHnswConfig(
+                                        HnswConfigDiff.newBuilder()
+                                            .setM(3)
+                                            .setEfConstruct(123)
+                                            .build())
+                                    .build())))
+            .setQuantizationConfig(
+                QuantizationConfigDiff.newBuilder()
+                    .setScalar(
+                        ScalarQuantization.newBuilder()
+                            .setType(QuantizationType.Int8)
+                            .setQuantile(0.8f)
+                            .setAlwaysRam(true)
+                            .build()))
+            .build())
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/python.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/python.md
new file mode 100644
index 000000000..2d48156f7
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/python.md
@@ -0,0 +1,30 @@
+```python
+client.update_collection(
+    collection_name="{collection_name}",
+    vectors_config={
+        "my_vector": models.VectorParamsDiff(
+            hnsw_config=models.HnswConfigDiff(
+                m=32,
+                ef_construct=123,
+            ),
+            quantization_config=models.ProductQuantization(
+                product=models.ProductQuantizationConfig(
+                    compression=models.CompressionRatio.X32,
+                    always_ram=True,
+                ),
+            ),
+            on_disk=True,
+        ),
+    },
+    hnsw_config=models.HnswConfigDiff(
+        ef_construct=123,
+    ),
+    quantization_config=models.ScalarQuantization(
+        scalar=models.ScalarQuantizationConfig(
+            type=models.ScalarType.INT8,
+            quantile=0.8,
+            always_ram=False,
+        ),
+    ),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/rust.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/rust.md
new file mode 100644
index 000000000..fb405fb64
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/rust.md
@@ -0,0 +1,31 @@
+```rust
+use std::collections::HashMap;
+
+use qdrant_client::qdrant::{
+    quantization_config_diff::Quantization, vectors_config_diff::Config, HnswConfigDiffBuilder,
+    QuantizationType, ScalarQuantizationBuilder, UpdateCollectionBuilder, VectorParamsDiffBuilder,
+    VectorParamsDiffMap,
+};
+
+client
+    .update_collection(
+        UpdateCollectionBuilder::new("{collection_name}")
+            .hnsw_config(HnswConfigDiffBuilder::default().ef_construct(123))
+            .vectors_config(Config::ParamsMap(VectorParamsDiffMap {
+                map: HashMap::from([(
+                    ("my_vector".into()),
+                    VectorParamsDiffBuilder::default()
+                        .hnsw_config(HnswConfigDiffBuilder::default().m(32).ef_construct(123))
+                        .build(),
+                )]),
+            }))
+            .quantization_config(Quantization::Scalar(
+                ScalarQuantizationBuilder::default()
+                    .r#type(QuantizationType::Int8.into())
+                    .quantile(0.8)
+                    .always_ram(true)
+                    .build(),
+            )),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/typescript.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/typescript.md
new file mode 100644
index 000000000..92d3bf7ad
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/hnsw-and-quantization/typescript.md
@@ -0,0 +1,29 @@
+```typescript
+client.updateCollection("{collection_name}", {
+  vectors: {
+    my_vector: {
+      hnsw_config: {
+        m: 32,
+        ef_construct: 123,
+      },
+      quantization_config: {
+        product: {
+          compression: "x32",
+          always_ram: true,
+        },
+      },
+      on_disk: true,
+    },
+  },
+  hnsw_config: {
+    ef_construct: 123,
+  },
+  quantization_config: {
+    scalar: {
+      type: "int8",
+      quantile: 0.8,
+      always_ram: true,
+    },
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/_description.md
new file mode 100644
index 000000000..35d3d5a49
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/_description.md
@@ -0,0 +1 @@
+Update collection parameters to adjust the optimizer's configuration. In this case, the code snippet demonstrates how to patch the collection by setting an indexing threshold of 10000 for more efficient initial loading of vectors. This allows you to optimize resource usage by enabling indexing selectively based on the number of vectors stored in each segment.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/bash.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/bash.md
new file mode 100644
index 000000000..ffd9428fa
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/bash.md
@@ -0,0 +1,9 @@
+```bash
+curl -X PATCH http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "optimizers_config": {
+        "indexing_threshold": 10000
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/csharp.md
new file mode 100644
index 000000000..762055145
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpdateCollectionAsync(
+	collectionName: "{collection_name}",
+	optimizersConfig: new OptimizersConfigDiff { IndexingThreshold = 10000 }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/go.md
new file mode 100644
index 000000000..e210db054
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/go.md
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
+	CollectionName: "{collection_name}",
+	OptimizersConfig: &qdrant.OptimizersConfigDiff{
+		IndexingThreshold: qdrant.PtrOf(uint64(10000)),
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/http.md
new file mode 100644
index 000000000..763de2551
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/http.md
@@ -0,0 +1,8 @@
+```http
+PATCH /collections/{collection_name}
+{
+    "optimizers_config": {
+        "indexing_threshold": 10000
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/java.md
new file mode 100644
index 000000000..3cecb9754
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/java.md
@@ -0,0 +1,11 @@
+```java
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.UpdateCollection;
+
+client.updateCollectionAsync(
+    UpdateCollection.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setOptimizersConfig(
+            OptimizersConfigDiff.newBuilder().setIndexingThreshold(10000).build())
+        .build());
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/python.md
new file mode 100644
index 000000000..f4a7e26e8
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/python.md
@@ -0,0 +1,6 @@
+```python
+client.update_collection(
+    collection_name="{collection_name}",
+    optimizers_config=models.OptimizersConfigDiff(indexing_threshold=10000),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/rust.md
new file mode 100644
index 000000000..4573ba6f4
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/rust.md
@@ -0,0 +1,11 @@
+```rust
+use qdrant_client::qdrant::{OptimizersConfigDiffBuilder, UpdateCollectionBuilder};
+
+client
+    .update_collection(
+        UpdateCollectionBuilder::new("{collection_name}").optimizers_config(
+            OptimizersConfigDiffBuilder::default().indexing_threshold(10000),
+        ),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/typescript.md
new file mode 100644
index 000000000..b6c2f8b97
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/simple/typescript.md
@@ -0,0 +1,7 @@
+```typescript
+client.updateCollection("{collection_name}", {
+  optimizers_config: {
+    indexing_threshold: 10000,
+  },
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/_description.md
new file mode 100644
index 000000000..cb31d1f74
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/_description.md
@@ -0,0 +1 @@
+This code snippet triggers the update process for a specific collection named "{collection_name}" to resume paused optimizations indicated by the grey status or "optimizations pending, awaiting update operation" message. By sending a PATCH request with an empty "optimizers_config" object, the update operation is initiated, allowing the ongoing optimizations to start again.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/bash.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/bash.md
new file mode 100644
index 000000000..222e937fb
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/bash.md
@@ -0,0 +1,7 @@
+```bash
+curl -X PATCH http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "optimizers_config": {}
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/csharp.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/csharp.md
new file mode 100644
index 000000000..8248c449e
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/csharp.md
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpdateCollectionAsync(
+	collectionName: "{collection_name}",
+	optimizersConfig: new OptimizersConfigDiff { }
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/go.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/go.md
new file mode 100644
index 000000000..0f7648e6d
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/go.md
@@ -0,0 +1,17 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.UpdateCollection(context.Background(), &qdrant.UpdateCollection{
+	CollectionName:   "{collection_name}",
+	OptimizersConfig: &qdrant.OptimizersConfigDiff{},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/http.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/http.md
new file mode 100644
index 000000000..f99e7d1c1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/http.md
@@ -0,0 +1,6 @@
+```http
+PATCH /collections/{collection_name}
+{
+    "optimizers_config": {}
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/java.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/java.md
new file mode 100644
index 000000000..4c4c4f7b6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/java.md
@@ -0,0 +1,11 @@
+```java
+import io.qdrant.client.grpc.Collections.OptimizersConfigDiff;
+import io.qdrant.client.grpc.Collections.UpdateCollection;
+
+client.updateCollectionAsync(
+    UpdateCollection.newBuilder()
+        .setCollectionName("{collection_name}")
+        .setOptimizersConfig(
+            OptimizersConfigDiff.getDefaultInstance())
+        .build());
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/python.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/python.md
new file mode 100644
index 000000000..c4a267e56
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/python.md
@@ -0,0 +1,6 @@
+```python
+client.update_collection(
+    collection_name="{collection_name}",
+    optimizer_config=models.OptimizersConfigDiff(),
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/rust.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/rust.md
new file mode 100644
index 000000000..6d8479f5c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/rust.md
@@ -0,0 +1,10 @@
+```rust
+use qdrant_client::qdrant::{OptimizersConfigDiffBuilder, UpdateCollectionBuilder};
+
+client
+    .update_collection(
+        UpdateCollectionBuilder::new("{collection_name}")
+            .optimizers_config(OptimizersConfigDiffBuilder::default()),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/typescript.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/typescript.md
new file mode 100644
index 000000000..24224f5c1
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/trigger-indexing/typescript.md
@@ -0,0 +1,5 @@
+```typescript
+client.updateCollection("{collection_name}", {
+  optimizers_config: {},
+});
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/_description.md
new file mode 100644
index 000000000..640c4036c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/_description.md
@@ -0,0 +1 @@
+Update the collection with patch requests to put vector data on disk. This functionality allows you to specify vector parameters, such as setting vectors to be stored on disk, for a specific collection. In cases where the collection does not have named vectors, an empty name (`""`) should be used to perform this update. This feature provided by Qdrant version 1.4 enables modifications to collection parameters, including HNSW index, quantization, and disk configurations dynamically, without the need to recreate the collection. Additionally, segments containing index and quantized data will be automatically rebuilt in the background to align with the new parameters.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/bash.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/bash.md
new file mode 100644
index 000000000..782f4ce32
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/bash.md
@@ -0,0 +1,11 @@
+```bash
+curl -X PATCH http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+        "": { 
+            "on_disk": true 
+      }
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/http.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/http.md
new file mode 100644
index 000000000..a7bacde62
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-default/http.md
@@ -0,0 +1,10 @@
+```http
+PATCH /collections/{collection_name}
+{
+    "vectors": {
+        "": {
+            "on_disk": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/_description.md
new file mode 100644
index 000000000..550f21b78
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/_description.md
@@ -0,0 +1 @@
+Update the collection by setting the vectors to be saved on disk for a specific vector named 'my_vector'. This code snippet demonstrates the configuration to ensure that the vector data is saved on disk within the collection.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/bash.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/bash.md
new file mode 100644
index 000000000..51c6bb9b2
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/bash.md
@@ -0,0 +1,11 @@
+```bash
+curl -X PATCH http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "vectors": {
+        "my_vector": { 
+           "on_disk": true 
+      }
+    }
+  }'
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/http.md b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/http.md
new file mode 100644
index 000000000..440ee33b6
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-collection/vectors-to-disk-named/http.md
@@ -0,0 +1,10 @@
+```http
+PATCH /collections/{collection_name}
+{
+    "vectors": {
+        "my_vector": {
+            "on_disk": true
+        }
+    }
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/_description.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/_description.md
new file mode 100644
index 000000000..227969838
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/_description.md
@@ -0,0 +1 @@
+This code snippet represents an operation to update vectors associated with points in a collection. The operation uses a PUT request to update vectors for specific points by providing their IDs along with the new vector data. This method ensures that only the specified vectors are updated, while leaving any unspecified vectors unchanged. It is important to note that all the provided points must already exist in the collection for the update to be successful.
\ No newline at end of file
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/csharp.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/csharp.md
new file mode 100644
index 000000000..bb0e9c583
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/csharp.md
@@ -0,0 +1,19 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpdateVectorsAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointVectors>
+	{
+		new() { Id = 1, Vectors = ("image", new float[] { 0.1f, 0.2f, 0.3f, 0.4f }) },
+		new()
+		{
+			Id = 2,
+			Vectors = ("text", new float[] { 0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f })
+		}
+	}
+);
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/go.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/go.md
new file mode 100644
index 000000000..3b678da6c
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/go.md
@@ -0,0 +1,30 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.UpdateVectors(context.Background(), &qdrant.UpdatePointVectors{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointVectors{
+		{
+			Id: qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"image": qdrant.NewVector(0.1, 0.2, 0.3, 0.4),
+			}),
+		},
+		{
+			Id: qdrant.NewIDNum(2),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"text": qdrant.NewVector(0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2),
+			}),
+		},
+	},
+})
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/http.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/http.md
new file mode 100644
index 000000000..0cef66960
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/http.md
@@ -0,0 +1,19 @@
+```http
+PUT /collections/{collection_name}/points/vectors
+{
+    "points": [
+        {
+            "id": 1,
+            "vector": {
+                "image": [0.1, 0.2, 0.3, 0.4]
+            }
+        },
+        {
+            "id": 2,
+            "vector": {
+                "text": [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2]
+            }
+        }
+    ]
+}
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/java.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/java.md
new file mode 100644
index 000000000..d4c647b47
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/java.md
@@ -0,0 +1,25 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.VectorFactory.vector;
+import static io.qdrant.client.VectorsFactory.namedVectors;
+
+client
+    .updateVectorsAsync(
+        "{collection_name}",
+        List.of(
+            PointVectors.newBuilder()
+                .setId(id(1))
+                .setVectors(namedVectors(Map.of("image", vector(List.of(0.1f, 0.2f, 0.3f, 0.4f)))))
+                .build(),
+            PointVectors.newBuilder()
+                .setId(id(2))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "text", vector(List.of(0.9f, 0.8f, 0.7f, 0.6f, 0.5f, 0.4f, 0.3f, 0.2f)))))
+                .build()))
+    .get();
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/python.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/python.md
new file mode 100644
index 000000000..7b6594e56
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/python.md
@@ -0,0 +1,19 @@
+```python
+client.update_vectors(
+    collection_name="{collection_name}",
+    points=[
+        models.PointVectors(
+            id=1,
+            vector={
+                "image": [0.1, 0.2, 0.3, 0.4],
+            },
+        ),
+        models.PointVectors(
+            id=2,
+            vector={
+                "text": [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
+            },
+        ),
+    ],
+)
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/rust.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/rust.md
new file mode 100644
index 000000000..17a80b5dc
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/rust.md
@@ -0,0 +1,34 @@
+```rust
+use std::collections::HashMap;
+
+use qdrant_client::qdrant::{
+    PointVectors, UpdatePointVectorsBuilder,
+};
+
+client
+    .update_vectors(
+        UpdatePointVectorsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointVectors {
+                    id: Some(1.into()),
+                    vectors: Some(
+                        HashMap::from([("image".to_string(), vec![0.1, 0.2, 0.3, 0.4])]).into(),
+                    ),
+                },
+                PointVectors {
+                    id: Some(2.into()),
+                    vectors: Some(
+                        HashMap::from([(
+                            "text".to_string(),
+                            vec![0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
+                        )])
+                        .into(),
+                    ),
+                },
+            ],
+        )
+        .wait(true),
+    )
+    .await?;
+```
diff --git a/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/typescript.md b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/typescript.md
new file mode 100644
index 000000000..2cac49945
--- /dev/null
+++ b/qdrant-landing/content/documentation/headless/snippets/update-vectors/simple/typescript.md
@@ -0,0 +1,18 @@
+```typescript
+client.updateVectors("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      vector: {
+        image: [0.1, 0.2, 0.3, 0.4],
+      },
+    },
+    {
+      id: 2,
+      vector: {
+        text: [0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2],
+      },
+    },
+  ],
+});
+```
diff --git a/qdrant-landing/themes/qdrant-2024/layouts/shortcodes/code-snippet.html b/qdrant-landing/themes/qdrant-2024/layouts/shortcodes/code-snippet.html
new file mode 100644
index 000000000..5247562fb
--- /dev/null
+++ b/qdrant-landing/themes/qdrant-2024/layouts/shortcodes/code-snippet.html
@@ -0,0 +1,84 @@
+<!-- Example usage: -->
+{{/* {{< code-snippet path="/documentation/headless/snippets/points-id/" order="python http go" > */}}
+<!-- Shortcode to render code snippets from a specified path -->
+<!-- path : The path to the directory containing the code snippets -->
+<!-- order : Optional. A space-separated list of snippet names to render first -->
+<!-- The rest will be rendered in the order they are found in the directory -->
+<!-- Global order of snippets is defined in the _index.md file of the section -->
+
+{{/* {{< code-snippet path="/path/to/snippets" order="snippet1 snippet2" > */}}
+
+
+<!-- Extract shortcode parameters -->
+{{ $path := .Get "path" }}
+{{ $order := .Get "order" }}
+
+
+<!-- Convert order string to a slice if provided -->
+{{ if $order }}
+  {{ $order = split $order " " }}
+{{ end }}
+
+
+<!-- If order is not provided, try to get it from the nearest _index.md -->
+{{ if not $order }}
+  {{ $currentPath := $path }}
+  {{ $foundOrder := false }}
+
+  {{ $currentPathParts := split $currentPath "/" }}
+  {{ $numParts := len $currentPathParts }}
+
+
+  <!-- Iterate from longest path to shortest -->
+  {{ range seq $numParts }}
+    {{ $index := sub $numParts . }}
+    {{ $currentPath = delimit (first (add $index 1) $currentPathParts) "/" }}
+
+    {{ $sectionPage := $.Site.GetPage "section" $currentPath }}
+    {{ if and $sectionPage $sectionPage.Params.snippetsOrder }}
+      {{ $order = $sectionPage.Params.snippetsOrder }}
+      {{ $foundOrder = true }}
+      {{ break }}
+    {{ end }}
+  {{ end }}
+
+
+  <!-- If no snippetsOrder found, set an empty order -->
+  {{ if not $foundOrder }}
+    {{ $order = slice }}
+  {{ end }}
+{{ end }}
+
+
+<!-- Read all files from the given path -->
+{{ $files := slice }}
+
+{{ range (readDir (printf "content/%s" $path)) }}
+  <!--- Skip files starting with `_` -->
+  {{ if strings.HasPrefix .Name "_" }}
+    {{ continue }}
+  {{ end }}
+
+  {{ if strings.HasSuffix .Name ".md" }}
+    {{ $filePath := printf "content/%s/%s" $path .Name }}
+    {{ $content := readFile $filePath | markdownify }}
+    {{ $files = $files | append (dict "name" (strings.TrimSuffix ".md" .Name) "content" $content) }}
+  {{ end }}
+{{ end }}
+
+
+<!-- Render snippets in the specified order first -->
+{{ range $order }}
+  {{ $snippet := index (where $files "name" .) 0 }}
+  {{ if $snippet }}
+    {{ $snippet.content | markdownify }}
+  {{ end }}
+{{ end }}
+
+
+<!-- Render remaining files that were not in the order list -->
+{{ range $files }}
+  {{ if not (in $order .name) }}
+    {{ .content | markdownify }}
+  {{ end }}
+{{ end }}
diff --git a/readme-assets/shortcode-snippets.png b/readme-assets/shortcode-snippets.png
new file mode 100644
index 000000000..d87b30abb
Binary files /dev/null and b/readme-assets/shortcode-snippets.png differ