other clients

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/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 PrefetchQuery { Query = new float[] { 0.2f, 0.8f, ..., .. }, Limit = 50 }, // <-- dense vector
+    ],
+    query: new Formula
+     {
+        Expression = new SumExpression
+        {
+            Sum = //  the final score = score + exp_decay(target_time - x_time)
+            {
+                "$score",
+                Expression.FromExpDecay(
+                    new()
+                    {
+                        X = Expression.FromDateTimeKey("update_time"),  // payload key
+                        Target = Expression.FromDateTime("YYYY-MM-DDT00:00:00Z"),  // current datetime
+                        Midpoint = 0.5f,
+                        Scale = 86400 // 1 day in seconds
+                    }
+                )
+            }
+        }
+    }
+);
+```

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/go.md

@@ -0,0 +1,35 @@
+```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.2, 0.8, .., ...), // <-- dense vector
+            Limit: qdrant.PtrOf(uint64(50)),
+        },
+    },
+    Query: qdrant.NewQueryFormula(&qdrant.Formula{
+        Expression: qdrant.NewExpressionSum(&qdrant.SumExpression{
+            Sum: []*qdrant.Expression{ //  the final score = score + exp_decay(target_time - x_time)
+                qdrant.NewExpressionVariable("$score"), 
+                qdrant.NewExpressionExpDecay(&qdrant.DecayParamsExpression{
+                    X: qdrant.NewExpressionDatetimeKey("update_time"), // payload key
+                    Target: qdrant.NewExpressionDatetime("YYYY-MM-DDT00:00:00Z"), // current datetime
+                    Scale:  qdrant.PtrOf(float32(86400)), // 1 day in seconds
+                    Midpoint: qdrant.PtrOf(float32(0.5)),
+                }),
+            },
+        }),
+    }),
+})
+```

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/http.md

@@ -4,7 +4,7 @@ POST /collections/{collection_name}/points/query
     "prefetch": {
         "query": [0.2, 0.8, ...],  // <-- dense vector
         "limit": 50
-    }
+    },
     "query": {
         "formula": {
             "sum": [

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/java.md

@@ -0,0 +1,43 @@
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.*;
+import java.util.List;
+
+import static io.qdrant.client.ExpressionFactory.*;
+import static io.qdrant.client.QueryFactory.*;
+import static io.qdrant.client.ValueFactory.*;
+
+QdrantClient client =
+  new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+List<ScoredPoint> time_boosted = client.queryAsync(
+    QueryPoints.newBuilder()
+        .setCollectionName({collection_name})
+        .addPrefetch(
+            PrefetchQuery.newBuilder()
+                .setQuery(nearest(0.2f, 0.8f, .., ..))  // <-- dense vector
+                .setLimit(50)
+                .build())
+        .setQuery(
+            formula(
+                Formula.newBuilder()
+                    .setExpression(
+                        sum( //  the final score = score + exp_decay(target_time - x_time)
+                            SumExpression.newBuilder()
+                                .addSum(variable("$score"))
+                                .addSum(
+                                    expDecay(
+                                        DecayParamsExpression.newBuilder()
+                                            .setX(
+                                                datetimeKey("update_time"))  // payload key
+                                            .setTarget(
+                                                datetime("YYYY-MM-DDT00:00:00Z"))  // current datetime
+                                            .setMidpoint(0.5f)
+                                            .setScale(86400)  // 1 day in seconds
+                                            .build()))
+                                .build()))
+                    .build()))
+        .build()
+).get();
+```

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/rust.md

@@ -0,0 +1,29 @@
+```rust
+use qdrant_client::qdrant::{
+    DecayParamsExpressionBuilder, Expression, FormulaBuilder, PrefetchQueryBuilder, QueryPointsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let _geo_boosted = client.query(
+    QueryPointsBuilder::new("{collection_name}")
+            .add_prefetch(
+                PrefetchQueryBuilder::default()
+                    .query(vec![0.2, 0.8, .., ..]) // <-- dense vector
+                    .limit(50u64),
+            )
+            .query(
+                FormulaBuilder::new(Expression::sum_with([ //  the final score = score + exp_decay(target_time - x_time)
+                    Expression::score(),
+                    Expression::exp_decay(
+                        DecayParamsExpressionBuilder::new(Expression::datetime_key("update_time")) // payload key
+                            .target(Expression::datetime("YYYY-MM-DDT00:00:00Z"))
+                            .midpoint(0.5)
+                            .scale(86400.0), // 1 day in seconds
+                    ),
+                ]))
+            )
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/query-points/score-boost-time/typescript.md

@@ -0,0 +1,31 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+const time_boosted = await client.query(collectionName, {
+  prefetch: {
+    query: [0.2, 0.8, ...], // <-- dense vector
+    limit: 50
+  },
+   query: {
+      formula: {
+          sum: [ //  the final score = score + exp_decay(target_time - x_time)
+              "$score",
+              {
+                  exp_decay: {
+                      x: {
+                          datetime_key: "update_time" // payload key
+                      },
+                      target: {
+                          datetime: "YYYY-MM-DDT00:00:00Z" // current datetime
+                      },
+                      midpoint: 0.5,
+                      scale: 86400 // 1 day in seconds
+                  }
+              }
+          ]
+      }
+  }
+});
+```