Merge pull request #1976 from abdonpijpelink/inference

Inference docs

qdrant-landing/content/documentation/headless/snippets/cloud-inference/image/csharp.md

@@ -16,7 +16,7 @@ await client.UpsertAsync(
     new() {
       Id = 1,
         Vectors = new Image() {
-          Image = "https://qdrant.tech/example.png",
+          Image_ = "https://qdrant.tech/example.png",
           Model = "qdrant/clip-vit-b-32-vision",
         },
         Payload = {

qdrant-landing/content/documentation/headless/snippets/cloud-inference/image/go.md

@@ -24,14 +24,14 @@ func main() {
     }
     defer client.Close()
 
-    _, err = client.GetPointsClient().Upsert(ctx, &qdrant.UpsertPoints{
+    _, err = client.Upsert(ctx, &qdrant.UpsertPoints{
         CollectionName: "<your-collection>",
         Points: []*qdrant.PointStruct{
             {
-                Id: qdrant.NewIDNum(uint64(1)),
+                Id: qdrant.NewIDNum(1),
                 Vectors: qdrant.NewVectorsImage(&qdrant.Image{
-                    Image: "https://qdrant.tech/example.png",
                     Model: "qdrant/clip-vit-b-32-vision",
+                    Image: qdrant.NewValueString("https://qdrant.tech/example.png"),
                 }),
                 Payload: qdrant.NewValueMap(map[string]any{
                     "title": "Example image",

qdrant-landing/content/documentation/headless/snippets/cloud-inference/image/java.md

@@ -32,7 +32,7 @@ public class Main {
           .setVectors(
             vectors(
               Image.newBuilder()
-              .setImage("https://qdrant.tech/example.png")
+              .setImage(value("https://qdrant.tech/example.png"))
               .setModel("qdrant/clip-vit-b-32-vision")
               .build()))
           .putAllPayload(Map.of("title", value("Example Image")))

qdrant-landing/content/documentation/headless/snippets/cloud-inference/simple/go.md

@@ -24,11 +24,11 @@ func main() {
     }
     defer client.Close()
 
-    _, err = client.GetPointsClient().Upsert(ctx, &qdrant.UpsertPoints{
+    _, err = client.Upsert(ctx, &qdrant.UpsertPoints{
         CollectionName: "<your-collection>",
         Points: []*qdrant.PointStruct{
             {
-                Id: qdrant.NewIDNum(uint64(1)),
+                Id: qdrant.NewIDNum(1),
                 Vectors: qdrant.NewVectorsDocument(&qdrant.Document{
                     Text:  "Recipe for baking chocolate chip cookies",
                     Model: "<the-model-to-use>",

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/_description.md

@@ -0,0 +1 @@
+This code snippet illustrates how to use the Cohere API for query-time inference on Qdrant Cloud. Instead of supplying an explicit query vector, the query provides text, along with the name of an Cohere model. When the model name is prepended with `cohere/`, the Qdrant Cloud Inference proxy uses the Cohere API to infer embeddings out of the provided text. Qdrant will search with the resulting vector. The request also shows how to pass Cohere-specific parameters to the API. In this case, the request provides the Cohere API key and the `dimensions` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/csharp.md

@@ -0,0 +1,21 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+  host: "xyz-example.qdrant.io",
+  port: 6334,
+  https: true,
+  apiKey: "<your-api-key>"
+);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new Document()
+    {
+        Model = "cohere/embed-v4.0",
+        Text = "a green square",
+        Options = { ["cohere-api-key"] = "<YOUR_COHERE_API_KEY>", ["output_dimension"] = 512 },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/go.md

@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host:   "xyz-example.qdrant.io",
+    Port:   6334,
+    APIKey: "<paste-your-api-key-here>",
+    UseTLS: true,
+})
+
+client.Query(ctx, &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQueryNearest(
+		qdrant.NewVectorInputDocument(&qdrant.Document{
+			Text:  "a green square",
+			Model: "cohere/embed-v4.0",
+			Options: qdrant.NewValueMap(map[string]any{
+				"cohere-api-key":   "<YOUR_COHERE_API_KEY>",
+				"output_dimension": 512,
+			}),
+		}),
+	),
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/http.md

@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "text": "a green square",
+    "model": "cohere/embed-v4.0",
+    "options": {
+      "cohere-api-key": "<YOUR_COHERE_API_KEY>",
+      "output_dimension": 512
+    }
+  }
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/java.md

@@ -0,0 +1,34 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ValueFactory.value;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Document;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .queryAsync(
+        Points.QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(
+                nearest(
+                    Document.newBuilder()
+                        .setModel("cohere/embed-v4.0")
+                        .setText("a green square")
+                        .putAllOptions(
+                            Map.of(
+                                "cohere-api-key",
+                                value("<YOUR_COHERE_API_KEY>"),
+                                "output_dimension",
+                                value(512)))
+                        .build()))
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/python.md

@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.Document(
+        text="a green square", 
+        model="cohere/embed-v4.0", 
+        options={
+            "cohere-api-key": "<your_cohere_api_key>", 
+            "output_dimension": 512
+        }
+    )
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Qdrant, QdrantError,
+    qdrant::{Document, Query, QueryPointsBuilder, Value},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("http://localhost:6333").build().unwrap();
+
+let mut options = HashMap::<String, Value>::new();
+options.insert("cohere-api-key".to_string(), "<YOUR_COHERE_API_KEY>".into());
+options.insert("output_dimension".to_string(), 512.into());
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(Document {
+                text: "a green square".into(),
+                model: "cohere/embed-v4.0".into(),
+                options,
+            }))
+            .build(),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-query/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}", {
+    query: {
+        text: 'a green square',
+        model: 'cohere/embed-v4.0',
+        options: {
+            'cohere-api-key': '<your_cohere_api_key>',
+            output_dimension: 512,
+        },
+    },
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/_description.md

@@ -0,0 +1 @@
+This code snippet demonstrates how to use the Cohere API for ingest-time inference on Qdrant Cloud. The example upserts a point, but instead of providing an explicit vector, the request includes text along with the name of a Cohere model. When the model name is prepended with `cohere/`, the Qdrant Cloud Inference proxy uses the Cohere API to infer embeddings out of the provided text. Qdrant will store the resulting vector. The request also shows how to pass Cohere-specific parameters to the API. In this case, the request provides the Cohere API key and the `output_dimension` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/csharp.md

@@ -0,0 +1,29 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+host: "xyz-example.qdrant.io", port: 6334, https: true, apiKey: "<your-api-key>");
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Image()
+            {
+                Model = "cohere/embed-v4.0",
+                Image_ =
+                    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNk+M9Qz0AEYBxVSF+FAAhKDveksOjmAAAAAElFTkSuQmCC",
+                Options =
+                {
+                    ["cohere-api-key"] = "<YOUR_COHERE_API_KEY>",
+                    ["output_dimension"] = 512,
+                },
+            },
+        },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/go.md

@@ -0,0 +1,32 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host:   "xyz-example.qdrant.io",
+    Port:   6334,
+    APIKey: "<paste-your-api-key-here>",
+    UseTLS: true,
+})
+
+client.Upsert(ctx, &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(uint64(1)),
+			Vectors: qdrant.NewVectorsImage(&qdrant.Image{
+				Model: "cohere/embed-v4.0",
+				Image: qdrant.NewValueString("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNk+M9Qz0AEYBxVSF+FAAhKDveksOjmAAAAAElFTkSuQmCC"),
+				Options: qdrant.NewValueMap(map[string]any{
+					"cohere-api-key":   "<YOUR_COHERE_API_KEY>",
+					"output_dimension": 512,
+				}),
+			}),
+		},
+	},
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/http.md

@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}/points?wait=true
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": {
+        "image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNk+M9Qz0AEYBxVSF+FAAhKDveksOjmAAAAAElFTkSuQmCC",
+        "model": "cohere/embed-v4.0",
+        "options": {
+          "cohere-api-key": "<YOUR_COHERE_API_KEY>",
+          "output_dimension": 512
+        }
+      }
+    }
+  ]
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/java.md

@@ -0,0 +1,41 @@
+```java
+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.Image;
+import io.qdrant.client.grpc.Points.PointStruct;
+import java.util.List;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    vectors(
+                        Image.newBuilder()
+                            .setModel("cohere/embed-v4.0")
+                            .setImage(
+                                value(
+                                    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAFUlEQVR42mNk+M9Qz0AEYBxVSF+FAAhKDveksOjmAAAAAElFTkSuQmCC"))
+                            .putAllOptions(
+                                Map.of(
+                                    "cohere-api-key",
+                                    value("<YOUR_COHERE_API_KEY>"),
+                                    "output_dimension",
+                                    value(512)))
+                            .build()))
+                .build()))
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/python.md

@@ -0,0 +1,26 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector=models.Document(
+                text="a green square",
+                model="cohere/embed-v4.0",
+                options={
+                    "cohere-api-key": "<your_cohere_api_key>",
+                    "output_dimension": 512
+                }
+            )
+        )
+    ]
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Payload, Qdrant, QdrantError,
+    qdrant::{Document, PointStruct, UpsertPointsBuilder},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build()?;
+let mut options = HashMap::new();
+options.insert("cohere-api-key".to_string(), "<YOUR_COHERE_API_KEY>".into());
+options.insert("output_dimension".to_string(), 512.into());
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}",
+        vec![
+            PointStruct::new(1,
+                Document {
+                  text: "Recipe for baking chocolate chip cookies requires flour, sugar, eggs, and chocolate chips.".into(),
+                  model: "openai/text-embedding-3-small".into(),
+                  options,
+                  },
+                Payload::default())
+            ]).wait(true))
+        .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/cohere-upsert/typescript.md

@@ -0,0 +1,21 @@
+```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: 'a green square',
+                model: 'cohere/embed-v4.0',
+                options: {
+                    'cohere-api-key': '<your_cohere_api_key>',
+                    output_dimension: 512,
+                },
+            },
+        },
+    ],
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/_description.md

@@ -0,0 +1 @@
+This code snippet shows how to use inference at ingest time. The example ingests a single point into a collection. Instead of providing an explicit vector, the request includes `text` and a `model`. Qdrant will use the model to infer embeddings out of the provided text and store the resulting vector.

qdrant-landing/content/documentation/headless/snippets/inference/ingest/csharp.md

@@ -0,0 +1,26 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+host: "xyz-example.qdrant.io", port: 6334, https: true, apiKey: "<your-api-key>");
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Dictionary<string, Vector>
+            {
+                ["my-bm25-vector"] = new Document()
+                {
+                    Model = "qdrant/bm25",
+                    Text = "Recipe for baking chocolate chip cookies",
+                },
+            },
+        },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/go.md

@@ -0,0 +1,30 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host:   "xyz-example.qdrant.io",
+    Port:   6334,
+    APIKey: "<paste-your-api-key-here>",
+    UseTLS: true,
+})
+
+client.Upsert(ctx, &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(uint64(1)),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"my-bm25-vector": qdrant.NewVectorDocument(&qdrant.Document{
+					Model: "qdrant/bm25",
+					Text:  "Recipe for baking chocolate chip cookies",
+				}),
+			}),
+		},
+	},
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/http.md

@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}/points
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": {
+        "my-bm25-vector": {
+          "text": "Recipe for baking chocolate chip cookies",
+          "model": "qdrant/bm25"
+        }
+      }
+    }
+  ]
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/java.md

@@ -0,0 +1,38 @@
+```java
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+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.Image;
+import io.qdrant.client.grpc.Points.PointStruct;
+import java.util.List;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "my-bm25-vector",
+                            vector(
+                                Document.newBuilder()
+                                    .setModel("qdrant/bm25")
+                                    .setText("Recipe for baking chocolate chip cookies")
+                                    .build()))))
+                .build()))
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/python.md

@@ -0,0 +1,24 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector={
+                "my-bm25-vector": models.Document(
+                    text="Recipe for baking chocolate chip cookies",
+                    model="Qdrant/bm25",
+                )
+            },
+        )
+    ],
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/rust.md

@@ -0,0 +1,22 @@
+```rust
+use qdrant_client::{
+    Payload, Qdrant, QdrantError,
+    qdrant::{Document, PointStruct, UpsertPointsBuilder},
+};
+
+let client = Qdrant::from_url("<your-qdrant-url>").build()?;
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}",
+        vec![
+            PointStruct::new(1,
+                HashMap::from([("my-bm25-vector".to_string(),
+                    Document {
+                      text: "Recipe for baking chocolate chip cookies".into(),
+                      model: "qdrant/bm25".into(),
+                      ..Default::default()
+                      }.into())]),
+                Payload::default())
+            ]))
+        .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/ingest/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: {
+                'my-bm25-vector': {
+                    text: 'Recipe for baking chocolate chip cookies',
+                    model: 'Qdrant/bm25',
+                },
+            },
+        },
+    ],
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/_description.md

@@ -0,0 +1 @@
+This code snippet illustrates how to use the Jina AI API for query-time inference on Qdrant Cloud. Instead of supplying an explicit query vector, the query provides text, along with the name of an Jina AI model. When the model name is prepended with `jinaai/`, the Qdrant Cloud Inference proxy uses the Jina AI API to infer embeddings out of the provided text. Qdrant will search with the resulting vector. The request also shows how to pass Jina AI-specific parameters to the API. In this case, the request provides the Jina AI API key and the `dimensions` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/csharp.md

@@ -0,0 +1,21 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+  host: "xyz-example.qdrant.io",
+  port: 6334,
+  https: true,
+  apiKey: "<your-api-key>"
+);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new Document()
+    {
+        Model = "jinaai/jina-clip-v2",
+        Text = "Mission to Mars",
+        Options = { ["jina-api-key"] = "<YOUR_JINAAI_API_KEY>", ["dimensions"] = 512 },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/go.md

@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+    Host:   "xyz-example.qdrant.io",
+    Port:   6334,
+    APIKey: "<paste-your-api-key-here>",
+    UseTLS: true,
+})
+
+client.Query(ctx, &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQueryNearest(
+		qdrant.NewVectorInputDocument(&qdrant.Document{
+			Text:  "Mission to Mars",
+			Model: "jinaai/jina-clip-v2",
+			Options: qdrant.NewValueMap(map[string]any{
+				"jina-api-key": "<YOUR_JINAAI_API_KEY>",
+				"dimensions":   512,
+			}),
+		}),
+	),
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/http.md

@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "text": "Mission to Mars",
+    "model": "jinaai/jina-clip-v2",
+    "options": {
+      "jina-api-key": "<YOUR_JINAAI_API_KEY>",
+      "dimensions": 512
+    }
+  }
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/java.md

@@ -0,0 +1,33 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ValueFactory.value;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Document;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+client
+    .queryAsync(
+        Points.QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(
+                nearest(
+                    Document.newBuilder()
+                        .setModel("jinaai/jina-clip-v2")
+                        .setText("Mission to Mars")
+                        .putAllOptions(
+                            Map.of(
+                                "jina-api-key",
+                                value("<YOUR_JINAAI_API_KEY>"),
+                                "dimensions",
+                                value(512)))
+                        .build()))
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/python.md

@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.Document(
+        text="Mission to Mars", 
+        model="jinaai/jina-clip-v2", 
+        options={
+            "jina-api-key": "<your_jinaai_api_key>", 
+            "dimensions": 512
+        }
+    )
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Qdrant, QdrantError,
+    qdrant::{Document, Query, QueryPointsBuilder, Value},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build().unwrap();
+
+let mut options = HashMap::<String, Value>::new();
+options.insert("jina-api-key".to_string(), "<YOUR_JINAAI_API_KEY>".into());
+options.insert("dimensions".to_string(), 512.into());
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(Document {
+                text: "Mission to Mars".into(),
+                model: "jinaai/jina-clip-v2".into(),
+                options,
+            }))
+            .build(),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-query/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}", {
+    query: {
+        text: 'Mission to Mars',
+        model: 'jinaai/jina-clip-v2',
+        options: {
+            'jina-api-key': '<your_jinaai_api_key>',
+            dimensions: 512,
+        },
+    },
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/_description.md

@@ -0,0 +1 @@
+This code snippet illustrates how to use the Jina AI API for ingest-time inference on Qdrant Cloud. The example upserts a point, but instead of providing an explicit vector, the request includes text along with the name of a Jina AI model. When the model name is prepended with `jinaai/`, the Qdrant Cloud Inference proxy uses the Jina AI API to infer embeddings out of the provided text. Qdrant will store the resulting vector. The request also shows how to pass Jina AI-specific parameters to the API. In this case, the request provides the Jina AI API key and the `dimensions` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/csharp.md

@@ -0,0 +1,28 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+  host: "xyz-example.qdrant.io",
+  port: 6334,
+  https: true,
+  apiKey: "<your-api-key>"
+);
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Document()
+            {
+                Model = "jinaai/jina-clip-v2",
+                Text = "Mission to Mars",
+                Options = { ["jina-api-key"] = "<YOUR_JINAAI_API_KEY>", ["dimensions"] = 512 },
+            },
+        },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/go.md

@@ -0,0 +1,32 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host:   "xyz-example.qdrant.io",
+	Port:   6334,
+	APIKey: "<paste-your-api-key-here>",
+	UseTLS: true,
+})
+
+client.Upsert(ctx, &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(uint64(1)),
+			Vectors: qdrant.NewVectorsImage(&qdrant.Image{
+				Model: "jinaai/jina-clip-v2",
+				Image: qdrant.NewValueString("https://qdrant.tech/example.png"),
+				Options: qdrant.NewValueMap(map[string]any{
+					"jina-api-key": "<YOUR_JINAAI_API_KEY>",
+					"dimensions":   512,
+				}),
+			}),
+		},
+	},
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/http.md

@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}/points?wait=true
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": {
+        "image": "https://qdrant.tech/example.png",
+        "model": "jinaai/jina-clip-v2",
+        "options": {
+          "jina-api-key": "<YOUR_JINAAI_API_KEY>",
+          "dimensions": 512
+        }
+      }
+    }
+  ]
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/java.md

@@ -0,0 +1,39 @@
+```java
+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.Image;
+import io.qdrant.client.grpc.Points.PointStruct;
+import java.util.List;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    vectors(
+                        Image.newBuilder()
+                            .setModel("jinaai/jina-clip-v2")
+                            .setImage(value("https://qdrant.tech/example.png"))
+                            .putAllOptions(
+                                Map.of(
+                                    "jina-api-key",
+                                    value("<YOUR_JINAAI_API_KEY>"),
+                                    "dimensions",
+                                    value(512)))
+                            .build()))
+                .build()))
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/python.md

@@ -0,0 +1,26 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector=models.Image(
+                image="https://qdrant.tech/example.png",
+                model="jinaai/jina-clip-v2",
+                options={
+                    "jina-api-key": "<your_jinaai_api_key>",
+                    "dimensions": 512
+                }
+            )
+        )
+    ]
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Payload, Qdrant, QdrantError,
+    qdrant::{Image, PointStruct, UpsertPointsBuilder},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build()?;
+let mut options = HashMap::new();
+options.insert("jina-api-key".to_string(), "<YOUR_JINAAI_API_KEY>".into());
+options.insert("dimensions".to_string(), 512.into());
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}",
+        vec![
+            PointStruct::new(1,
+                Image {
+                  image: Some("https://qdrant.tech/example.png".into()),
+                  model: "jinaai/jina-clip-v2".into(),
+                  options,
+                  },
+                Payload::default())
+            ]).wait(true))
+        .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/jinaai-upsert/typescript.md

@@ -0,0 +1,21 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+    points: [
+        {
+            id: 1,
+            vector: {
+                image: 'https://qdrant.tech/example.png',
+                model: 'jinaai/jina-clip-v2',
+                options: {
+                    'jina-api-key': '<your_jinaai_api_key>',
+                    dimensions: 512,
+                },
+            },
+        },
+    ],
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/_description.md

@@ -0,0 +1 @@
+This code snippet shows how to run multiple inference operations within a single request, even when models are hosted in different locations. The request generates three different named vectors for a single point: image embeddings using `jina-clip-v2` hosted by Jina AI, text embeddings using `all-minilm-l6-v2` hosted by Qdrant Cloud, and BM25 embeddings using the `bm25` model executed locally by the Qdrant cluster.

qdrant-landing/content/documentation/headless/snippets/inference/multiple/csharp.md

@@ -0,0 +1,33 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+host: "xyz-example.qdrant.io", port: 6334, https: true, apiKey: "<your-api-key>");
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Dictionary<string, Vector>
+            {
+                ["image"] = new Image()
+                {
+                    Model = "jinaai/jina-clip-v2",
+                    Image_ = "https://qdrant.tech/example.png",
+                    Options = { ["jina-api-key"] = "<YOUR_JINAAI_API_KEY>", ["dimensions"] = 512 },
+                },
+                ["text"] = new Document()
+                {
+                    Model = "sentence-transformers/all-minilm-l6-v2",
+                    Text = "Mars, the red planet",
+                },
+                ["bm25"] = new Document() { Model = "qdrant/bm25", Text = "Mars, the red planet" },
+            },
+        },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/go.md

@@ -0,0 +1,42 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host:   "xyz-example.qdrant.io",
+	Port:   6334,
+	APIKey: "<paste-your-api-key-here>",
+	UseTLS: true,
+})
+
+client.Upsert(ctx, &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(uint64(1)),
+			Vectors: qdrant.NewVectorsMap(map[string]*qdrant.Vector{
+				"image": qdrant.NewVectorImage(&qdrant.Image{
+					Model: "jinaai/jina-clip-v2",
+					Image: qdrant.NewValueString("https://qdrant.tech/example.png"),
+					Options: qdrant.NewValueMap(map[string]any{
+						"jina-api-key": "<YOUR_JINAAI_API_KEY>",
+						"dimensions":   512,
+					}),
+				}),
+				"text": qdrant.NewVectorDocument(&qdrant.Document{
+					Model: "sentence-transformers/all-minilm-l6-v2",
+					Text:  "Mars, the red planet",
+				}),
+				"my-bm25-vector": qdrant.NewVectorDocument(&qdrant.Document{
+					Model: "qdrant/bm25",
+					Text:  "Recipe for baking chocolate chip cookies",
+				}),
+			}),
+		},
+	},
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/http.md

@@ -0,0 +1,28 @@
+```http
+PUT /collections/{collection_name}/points?wait=true
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": {
+        "image": {
+          "image": "https://qdrant.tech/example.png",
+          "model": "jinaai/jina-clip-v2",
+          "options": {
+            "jina-api-key": "<YOUR_JINAAI_API_KEY>",
+            "dimensions": 512
+          }
+        },
+        "text": {
+          "text": "Mars, the red planet",
+          "model": "sentence-transformers/all-minilm-l6-v2"
+        },
+        "bm25": {
+          "text": "Mars, the red planet",
+          "model": "qdrant/bm25"
+        }
+      }
+    }
+  ]
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/java.md

@@ -0,0 +1,56 @@
+```java
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ValueFactory.value;
+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.Document;
+import io.qdrant.client.grpc.Points.Image;
+import io.qdrant.client.grpc.Points.PointStruct;
+import java.util.List;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    namedVectors(
+                        Map.of(
+                            "image",
+                            vector(
+                                Image.newBuilder()
+                                    .setModel("jinaai/jina-clip-v2")
+                                    .setImage(value("https://qdrant.tech/example.png"))
+                                    .putAllOptions(
+                                        Map.of(
+                                            "jina-api-key",
+                                            value("<YOUR_JINAAI_API_KEY>"),
+                                            "dimensions",
+                                            value(512)))
+                                    .build()),
+                            "text",
+                            vector(
+                                Document.newBuilder()
+                                    .setModel("sentence-transformers/all-minilm-l6-v2")
+                                    .setText("Mars, the red planet")
+                                    .build()),
+                            "bm25",
+                            vector(
+                                Document.newBuilder()
+                                    .setModel("qdrant/bm25")
+                                    .setText("Mars, the red planet")
+                                    .build()))))
+                .build()))
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/python.md

@@ -0,0 +1,37 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333",
+    api_key="<your-api-key>",
+    cloud_inference=True
+)
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector={
+                "image": models.Image(
+                    image="https://qdrant.tech/example.png",
+                    model="jinaai/jina-clip-v2",
+                    options={
+                        "jina-api-key": "<your_jinaai_api_key>",
+                        "dimensions": 512
+                    },
+                ),
+                "text": models.Document(
+                    text="Mars, the red planet",
+                    model="sentence-transformers/all-minilm-l6-v2",
+                ),
+                "bm25": models.Document(
+                    text="Mars, the red planet",
+                    model="Qdrant/bm25",
+                ),
+            },
+        )
+    ],
+)
+
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/rust.md

@@ -0,0 +1,51 @@
+```rust
+use qdrant_client::{
+    Payload, Qdrant, QdrantError,
+    qdrant::{Document, PointStruct, UpsertPointsBuilder, Vectors},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build()?;
+
+let mut jina_options = HashMap::new();
+jina_options.insert("jina-api-key".to_string(), "<YOUR_JINAAI_API_KEY>".into());
+jina_options.insert("dimensions".to_string(), 512.into());
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![PointStruct::new(
+                1,
+                NamedVectors::default()
+                    .add_vector(
+                        "image",
+                        Image {
+                            image: Some("https://qdrant.tech/example.png".into()),
+                            model: "jinaai/jina-clip-v2".into(),
+                            options: jina_options,
+                        },
+                    )
+                    .add_vector(
+                        "text",
+                        Document {
+                            text: "Mars, the red planet".into(),
+                            model: "sentence-transformers/all-minilm-l6-v2".into(),
+                            ..Default::default()
+                        },
+                    )
+                    .add_vector(
+                        "bm25",
+                        Document {
+                            text: "How to bake cookies?".into(),
+                            model: "qdrant/bm25".into(),
+                            ..Default::default()
+                        },
+                    ),
+                Payload::default(),
+            )],
+        )
+        .wait(true),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/multiple/typescript.md

@@ -0,0 +1,31 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+    points: [
+        {
+            id: 1,
+            vector: {
+                image: {
+                    image: 'https://qdrant.tech/example.png',
+                    model: 'jinaai/jina-clip-v2',
+                    options: {
+                        'jina-api-key': '<your_jinaai_api_key>',
+                        dimensions: 512,
+                    },
+                },
+                text: {
+                    text: 'Mars, the red planet',
+                    model: 'sentence-transformers/all-minilm-l6-v2',
+                },
+                bm25: {
+                    text: 'Mars, the red planet',
+                    model: 'Qdrant/bm25',
+                },
+            },
+        },
+    ],
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/_description.md

@@ -0,0 +1 @@
+This code snippet illustrates how to use the OpenAI API for query-time inference on Qdrant Cloud. Instead of supplying an explicit query vector, the query provides text, along with the name of an OpenAI model. When the model name is prepended with `openai/`, the Qdrant Cloud Inference proxy uses the OpenAI API to infer embeddings out of the provided text. Qdrant will search with the resulting vector. The request also shows how to pass OpenAI-specific parameters to the API. In this case, the request provides the OpenAI API key and the `dimensions` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/csharp.md

@@ -0,0 +1,21 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+  host: "xyz-example.qdrant.io",
+  port: 6334,
+  https: true,
+  apiKey: "<your-api-key>"
+);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new Document()
+    {
+        Model = "openai/text-embedding-3-large",
+        Text = "How to bake cookies?",
+        Options = { ["openai-api-key"] = "<YOUR_OPENAI_API_KEY>", ["dimensions"] = 512 },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/go.md

@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host:   "xyz-example.qdrant.io",
+	Port:   6334,
+	APIKey: "<paste-your-api-key-here>",
+	UseTLS: true,
+})
+
+client.Query(ctx, &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQueryNearest(
+		qdrant.NewVectorInputDocument(&qdrant.Document{
+			Model: "openai/text-embedding-3-large",
+			Text:  "How to bake cookies?",
+			Options: qdrant.NewValueMap(map[string]any{
+				"openai-api-key": "<YOUR_OPENAI_API_KEY>",
+				"dimensions":     512,
+			}),
+		}),
+	),
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/http.md

@@ -0,0 +1,13 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "text": "How to bake cookies?",
+    "model": "openai/text-embedding-3-large",
+    "options": {
+      "openai-api-key": "<YOUR_OPENAI_API_KEY>",
+      "dimensions": 512
+    }
+  }
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/java.md

@@ -0,0 +1,33 @@
+```java
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ValueFactory.value;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.Document;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+client
+    .queryAsync(
+        Points.QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(
+                nearest(
+                    Document.newBuilder()
+                        .setModel("openai/text-embedding-3-large")
+                        .setText("How to bake cookies?")
+                        .putAllOptions(
+                            Map.of(
+                                "openai-api-key",
+                                value("<YOUR_OPENAI_API_KEY>"),
+                                "dimensions",
+                                value(512)))
+                        .build()))
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/python.md

@@ -0,0 +1,21 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333",
+    api_key="<your-api-key>",
+    cloud_inference=True
+)
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.Document(
+        text="How to bake cookies?",
+        model="openai/text-embedding-3-large",
+        options={
+            "openai-api-key": "<your_openai_api_key>",
+            "dimensions": 512
+        }
+    )
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Qdrant, QdrantError,
+    qdrant::{Document, Query, QueryPointsBuilder, Value},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build().unwrap();
+
+let mut options = HashMap::<String, Value>::new();
+options.insert("openai-api-key".to_string(), "<YOUR_OPENAI_API_KEY>".into());
+options.insert("dimensions".to_string(), 512.into());
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(Document {
+                text: "How to bake cookies?".into(),
+                model: "openai/text-embedding-3-large".into(),
+                options,
+            }))
+            .build(),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-query/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}", {
+    query: {
+        text: 'How to bake cookies?',
+        model: 'openai/text-embedding-3-large',
+        options: {
+            'openai-api-key': '<your_openai_api_key>',
+            dimensions: 512,
+        },
+    },
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/_description.md

@@ -0,0 +1 @@
+This code snippet illustrates how to use the OpenAI API for ingest-time inference on Qdrant Cloud. The example upserts a point, but instead of providing an explicit vector, the request includes text along with the name of an OpenAI model. When the model name is prepended with `openai/`, the Qdrant Cloud Inference proxy uses the OpenAI API to infer embeddings out of the provided text. Qdrant will store the resulting vector. The request also shows how to pass OpenAI-specific parameters to the API. In this case, the request provides the OpenAI API key and the `dimensions` parameter.

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/csharp.md

@@ -0,0 +1,24 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+host: "xyz-example.qdrant.io", port: 6334, https: true, apiKey: "<your-api-key>");
+
+await client.UpsertAsync(
+    collectionName: "{collection_name}",
+    points: new List<PointStruct>
+    {
+        new()
+        {
+            Id = 1,
+            Vectors = new Document()
+            {
+                Model = "openai/text-embedding-3-large",
+                Text = "Recipe for baking chocolate chip cookies",
+                Options = { ["openai-api-key"] = "<YOUR_OPENAI_API_KEY>", ["dimensions"] = 512 },
+            },
+        },
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/go.md

@@ -0,0 +1,32 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host:   "xyz-example.qdrant.io",
+	Port:   6334,
+	APIKey: "<paste-your-api-key-here>",
+	UseTLS: true,
+})
+
+client.Upsert(ctx, &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id: qdrant.NewIDNum(uint64(1)),
+			Vectors: qdrant.NewVectorsDocument(&qdrant.Document{
+				Model: "openai/text-embedding-3-large",
+				Text:  "Recipe for baking chocolate chip cookies",
+				Options: qdrant.NewValueMap(map[string]any{
+					"openai-api-key": "<YOUR_OPENAI_API_KEY>",
+					"dimensions":     512,
+				}),
+			}),
+		},
+	},
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/http.md

@@ -0,0 +1,18 @@
+```http
+PUT /collections/{collection_name}/points?wait=true
+{
+  "points": [
+    {
+      "id": 1,
+      "vector": {
+        "text": "Recipe for baking chocolate chip cookies",
+        "model": "openai/text-embedding-3-large",
+        "options": {
+          "openai-api-key": "<YOUR_OPENAI_API_KEY>",
+          "dimensions": 512
+        }
+      }
+    }
+  ]
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/java.md

@@ -0,0 +1,39 @@
+```java
+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.Document;
+import io.qdrant.client.grpc.Points.PointStruct;
+import java.util.List;
+import java.util.Map;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+
+client
+    .upsertAsync(
+        "{collection_name}",
+        List.of(
+            PointStruct.newBuilder()
+                .setId(id(1))
+                .setVectors(
+                    vectors(
+                        Document.newBuilder()
+                            .setModel("openai/text-embedding-3-large")
+                            .setText("Recipe for baking chocolate chip cookies")
+                            .putAllOptions(
+                                Map.of(
+                                    "openai-api-key",
+                                    value("<YOUR_OPENAI_API_KEY>"),
+                                    "dimensions",
+                                    value(512)))
+                            .build()))
+                .build()))
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/python.md

@@ -0,0 +1,26 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            vector=models.Document(
+                text="Recipe for baking chocolate chip cookies",
+                model="openai/text-embedding-3-large",
+                options={
+                    "openai-api-key": "<your_openai_api_key>",
+                    "dimensions": 512
+                }
+            )
+        )
+    ]
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/rust.md

@@ -0,0 +1,25 @@
+```rust
+use qdrant_client::{
+    Payload, Qdrant, QdrantError,
+    qdrant::{Document, PointStruct, UpsertPointsBuilder},
+};
+use std::collections::HashMap;
+
+let client = Qdrant::from_url("<your-qdrant-url>").build()?;
+let mut options = HashMap::new();
+options.insert("openai-api-key".to_string(), "<YOUR_OPENAI_API_KEY>".into());
+options.insert("dimensions".to_string(), 512.into());
+
+client
+    .upsert_points(UpsertPointsBuilder::new("{collection_name}",
+        vec![
+            PointStruct::new(1,
+                Document {
+                  text: "Recipe for baking chocolate chip cookies".into(),
+                  model: "openai/text-embedding-3-large".into(),
+                  options,
+                  },
+                Payload::default())
+            ]).wait(true))
+        .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/openai-upsert/typescript.md

@@ -0,0 +1,21 @@
+```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: 'Recipe for baking chocolate chip cookies',
+                model: 'openai/text-embedding-3-large',
+                options: {
+                    'openai-api-key': '<your_openai_api_key>',
+                    dimensions: 512,
+                },
+            },
+        },
+    ],
+});
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/_description.md

@@ -0,0 +1 @@
+This code snippet shows how to use inference at query time. The example queries a collection. Instead of providing an explicit query vector, the request includes `text` and a `model`. Qdrant will use the model to infer embeddings out of the provided text and search with the resulting vector.

qdrant-landing/content/documentation/headless/snippets/inference/query/csharp.md

@@ -0,0 +1,17 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient(
+  host: "xyz-example.qdrant.io",
+  port: 6334,
+  https: true,
+  apiKey: "<your-api-key>"
+);
+
+await client.QueryAsync(
+    collectionName: "{collection_name}",
+    query: new Document() { Model = "qdrant/bm25", Text = "How to bake cookies?" },
+    usingVector: "my-bm25-vector"
+);
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/go.md

@@ -0,0 +1,26 @@
+```go
+import (
+	"context"
+	"time"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host:   "xyz-example.qdrant.io",
+	Port:   6334,
+	APIKey: "<paste-your-api-key-here>",
+	UseTLS: true,
+})
+
+client.Query(ctx, &qdrant.QueryPoints{
+	CollectionName: "{collection_name}",
+	Query: qdrant.NewQueryNearest(
+		qdrant.NewVectorInputDocument(&qdrant.Document{
+			Model: "qdrant/bm25",
+			Text:  "How to bake cookies?",
+		}),
+	),
+	Using: qdrant.PtrOf("my-bm25-vector"),
+})
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/http.md

@@ -0,0 +1,10 @@
+```http
+POST /collections/{collection_name}/points/query
+{
+  "query": {
+    "text": "How to bake cookies?",
+    "model": "qdrant/bm25"
+  },
+  "using": "my-bm25-vector"
+}
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/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;
+import io.qdrant.client.grpc.Points.Document;
+
+QdrantClient client =
+    new QdrantClient(
+        QdrantGrpcClient.newBuilder("xyz-example.qdrant.io", 6334, true)
+            .withApiKey("<your-api-key")
+            .build());
+client
+    .queryAsync(
+        Points.QueryPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setQuery(
+                nearest(
+                    Document.newBuilder()
+                        .setModel("qdrant/bm25")
+                        .setText("How to bake cookies?")
+                        .build()))
+            .setUsing("my-bm25-vector")
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/python.md

@@ -0,0 +1,18 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(
+    url="https://xyz-example.qdrant.io:6333", 
+    api_key="<your-api-key>", 
+    cloud_inference=True
+)
+
+client.query_points(
+    collection_name="{collection_name}",
+    query=models.Document(
+        text="How to bake cookies?", 
+        model="Qdrant/bm25",
+    ),
+    using="my-bm25-vector",
+)
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/rust.md

@@ -0,0 +1,21 @@
+```rust
+use qdrant_client::{
+    Qdrant, QdrantError,
+    qdrant::{Document, Query, QueryPointsBuilder},
+};
+
+let client = Qdrant::from_url("<your-qdrant-url>").build().unwrap();
+
+client
+    .query(
+        QueryPointsBuilder::new("{collection_name}")
+            .query(Query::new_nearest(Document {
+                text: "How to bake cookies?".into(),
+                model: "qdrant/bm25".into(),
+                ..Default::default()
+            }))
+            .using("my-bm25-vector")
+            .build(),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/inference/query/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: {
+        text: 'How to bake cookies?',
+        model: 'qdrant/bm25',
+    },
+    using: 'my-bm25-vector',
+});
+```