From 42c45bcc594fd6e7a3d043c0ca6f55edfe81deaa Mon Sep 17 00:00:00 2001 From: shaurya2k06 Date: Thu, 16 Jul 2026 20:32:26 +0530 Subject: [PATCH 1/9] docs: add missing tags for Hybrid and related overloads Document every parameter on the 30 public methods that previously had only a , including boost, so IntelliSense matches the rest of the query/generate API. Signed-off-by: shaurya2k06 --- src/Weaviate.Client/GenerateClient.Hybrid.cs | 129 ++++++++++++++++++ .../GenerateClient.NearVector.cs | 70 ++++++++++ src/Weaviate.Client/QueryClient.Hybrid.cs | 111 +++++++++++++++ src/Weaviate.Client/QueryClient.NearText.cs | 27 ++++ .../Typed/TypedGenerateClient.Hybrid.cs | 129 ++++++++++++++++++ .../Typed/TypedQueryClient.Hybrid.cs | 111 +++++++++++++++ 6 files changed, 577 insertions(+) diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index 3a59cf17..b833d730 100644 --- a/src/Weaviate.Client/GenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/GenerateClient.Hybrid.cs @@ -11,6 +11,26 @@ public partial class GenerateClient /// /// Hybrid search with generative AI capabilities. /// + /// The query + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task Hybrid( string query, float? alpha = null, @@ -60,6 +80,27 @@ public Task Hybrid( /// /// Hybrid search with generative AI capabilities. /// + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -123,6 +164,27 @@ public async Task Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// + /// The query + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task Hybrid( string query, GroupByRequest groupBy, @@ -174,6 +236,28 @@ public Task Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -256,6 +340,28 @@ public static class GenerateClientHybridExtensions /// singlePrompt: "Describe this item" /// ); /// + /// The client + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task Hybrid( this GenerateClient client, string query, @@ -308,6 +414,29 @@ await client.Hybrid( /// Hybrid search with generative AI capabilities and grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// + /// The client + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task Hybrid( this GenerateClient client, string query, diff --git a/src/Weaviate.Client/GenerateClient.NearVector.cs b/src/Weaviate.Client/GenerateClient.NearVector.cs index 9d675cd2..430da230 100644 --- a/src/Weaviate.Client/GenerateClient.NearVector.cs +++ b/src/Weaviate.Client/GenerateClient.NearVector.cs @@ -11,6 +11,23 @@ public partial class GenerateClient /// /// Search near vector with generative AI capabilities. /// + /// The vectors + /// The filters + /// The certainty + /// The distance + /// The auto limit + /// The limit + /// The offset + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task NearVector( VectorSearchInput vectors, Filter? filters = null, @@ -55,6 +72,24 @@ await _client.GrpcClient.SearchNearVector( /// /// Search near vector with generative AI capabilities and grouping. /// + /// The vectors + /// The group by + /// The filters + /// The certainty + /// The distance + /// The auto limit + /// The limit + /// The offset + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task NearVector( VectorSearchInput vectors, GroupByRequest groupBy, @@ -101,6 +136,23 @@ await _client.GrpcClient.SearchNearVector( /// /// Search near vector with generative AI capabilities using lambda builder. /// + /// The vectors + /// The filters + /// The certainty + /// The distance + /// The auto limit + /// The limit + /// The offset + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task NearVector( VectorSearchInput.FactoryFn vectors, Filter? filters = null, @@ -143,6 +195,24 @@ await NearVector( /// /// Search near vector with generative AI capabilities and grouping using lambda builder. /// + /// The vectors + /// The group by + /// The filters + /// The certainty + /// The distance + /// The auto limit + /// The limit + /// The offset + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task NearVector( VectorSearchInput.FactoryFn vectors, GroupByRequest groupBy, diff --git a/src/Weaviate.Client/QueryClient.Hybrid.cs b/src/Weaviate.Client/QueryClient.Hybrid.cs index 368cb009..0cdba080 100644 --- a/src/Weaviate.Client/QueryClient.Hybrid.cs +++ b/src/Weaviate.Client/QueryClient.Hybrid.cs @@ -11,6 +11,23 @@ public partial class QueryClient /// /// Performs a hybrid search (keyword + vector search). /// + /// The query + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task Hybrid( string query, float? alpha = null, @@ -54,6 +71,24 @@ public Task Hybrid( /// /// Performs a hybrid search (keyword + vector search). /// + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -110,6 +145,24 @@ public async Task Hybrid( /// /// Performs a hybrid search (keyword + vector search) with grouping. /// + /// The query + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task Hybrid( string query, GroupByRequest groupBy, @@ -155,6 +208,25 @@ public Task Hybrid( /// /// Performs a hybrid search (keyword + vector search) with grouping. /// + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -229,6 +301,25 @@ public static class QueryClientHybridExtensions /// ) /// ); /// + /// The query client + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task Hybrid( this QueryClient client, string? query = null, @@ -279,6 +370,26 @@ public static async Task Hybrid( /// Performs a hybrid search (keyword + vector search) with grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// + /// The query client + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task Hybrid( this QueryClient client, string? query, diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index 10599f99..35e3e8f9 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -263,6 +263,19 @@ public static class QueryClientNearTextExtensions /// /// Performs a near-text search using a NearTextInput record. /// + /// The query client + /// The near-text input + /// Filters to apply to the search. + /// Maximum number of results to return. + /// Number of results to skip. + /// Automatic result cutoff threshold. + /// Re-ranking configuration. + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Properties to return in the response. + /// Cross-references to return. + /// Metadata to include in the response. + /// Vector configuration for returned objects. + /// Cancellation token. public static async Task NearText( this QueryClient client, NearTextInput query, @@ -322,6 +335,20 @@ public static async Task NearText( /// /// Performs a near-text search with group-by using a NearTextInput record. /// + /// The query client + /// The near-text input + /// Group-by configuration. + /// Filters to apply to the search. + /// Maximum number of results to return. + /// Number of results to skip. + /// Automatic result cutoff threshold. + /// Re-ranking configuration. + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Properties to return in the response. + /// Cross-references to return. + /// Metadata to include in the response. + /// Vector configuration for returned objects. + /// Cancellation token. public static async Task NearText( this QueryClient client, NearTextInput query, diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs index c9cb9913..71b156d9 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs @@ -12,6 +12,26 @@ public partial class TypedGenerateClient /// /// Hybrid search with generative AI capabilities (query-only, no vectors). /// + /// The query + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task> Hybrid( string query, float? alpha = null, @@ -61,6 +81,27 @@ public Task> Hybrid( /// /// Hybrid search with generative AI capabilities. /// + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -114,6 +155,27 @@ public async Task> Hybrid( /// /// Hybrid search with generative AI capabilities and grouping (query-only, no vectors). /// + /// The query + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task> Hybrid( string query, GroupByRequest groupBy, @@ -165,6 +227,28 @@ public Task> Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -227,6 +311,28 @@ public static class TypedGenerateClientHybridExtensions /// Hybrid search with generative AI capabilities using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// + /// The client + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task> Hybrid( this TypedGenerateClient client, string query, @@ -280,6 +386,29 @@ await client.Hybrid( /// Hybrid search with generative AI capabilities and grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// + /// The client + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The single prompt + /// The grouped task + /// The provider + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task> Hybrid( this TypedGenerateClient client, string query, diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs index 62ca455c..46fabf07 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs @@ -12,6 +12,23 @@ public partial class TypedQueryClient /// /// Performs a hybrid search using keyword search only. /// + /// The query + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task>> Hybrid( string query, float? alpha = null, @@ -55,6 +72,24 @@ public Task>> Hybrid( /// /// Performs a hybrid search combining keyword and vector search. /// + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task>> Hybrid( string? query, HybridVectorInput? vectors, @@ -102,6 +137,24 @@ public async Task>> Hybrid( /// /// Performs a hybrid search with group-by aggregation using keyword search only. /// + /// The query + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public Task> Hybrid( string query, GroupByRequest groupBy, @@ -147,6 +200,25 @@ public Task> Hybrid( /// /// Performs a hybrid search with group-by aggregation. /// + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -222,6 +294,25 @@ public static class TypedQueryClientHybridExtensions /// ) /// ); /// + /// The client + /// The query + /// The vectors + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task>> Hybrid( this TypedQueryClient client, string query, @@ -269,6 +360,26 @@ await client.Hybrid( /// Performs a hybrid search (keyword + vector search) with grouping using a lambda to build HybridVectorInput. /// Supports NearVector, NearText, or direct vector input via .Vectors(). /// + /// The client + /// The query + /// The vectors + /// The group by + /// The alpha + /// The query properties + /// The fusion type + /// The max vector distance + /// The limit + /// The offset + /// The bm 25 operator + /// The auto limit + /// The filters + /// The rerank + /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// The return properties + /// The return references + /// The return metadata + /// The include vectors + /// The cancellation token public static async Task> Hybrid( this TypedQueryClient client, string query, From dab0af057df9ac66764589abf325a2fc2499399c Mon Sep 17 00:00:00 2001 From: shaurya2k06 Date: Thu, 16 Jul 2026 20:34:35 +0530 Subject: [PATCH 2/9] ci: guard query/generate XML param docs in preflight Add ci/check_xml_param_docs.py to fail when a public QueryClient, GenerateClient, or typed query/generate method has a but missing or incomplete tags. Wire it into preflight so Hybrid-style gaps cannot regress silently. Signed-off-by: shaurya2k06 --- .github/workflows/main.yaml | 3 + ci/check_xml_param_docs.py | 118 ++++++++++++++++++++++++++++++++++++ 2 files changed, 121 insertions(+) create mode 100755 ci/check_xml_param_docs.py diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index e2fb139b..e051e134 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -101,6 +101,9 @@ jobs: dotnet tool restore dotnet csharpier check $CHANGED_FILES + - name: Check XML param docs (query/generate API) + run: python3 ci/check_xml_param_docs.py + - name: Run analyzer unit tests run: | if [[ "${{ needs.setup.outputs.dry-run }}" == "true" ]]; then diff --git a/ci/check_xml_param_docs.py b/ci/check_xml_param_docs.py new file mode 100755 index 00000000..feacd25a --- /dev/null +++ b/ci/check_xml_param_docs.py @@ -0,0 +1,118 @@ +#!/usr/bin/env python3 +"""Fail when public query/generate methods document a summary but not their parameters. + +CS1573 only fires when some parameters are documented but not all; CS1591 only +fires when the method has no doc comment at all. Methods with a and +zero tags (Hybrid before this fix) slip through both. This check closes +that gap for the query/generate client surface. +""" + +from __future__ import annotations + +import re +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +CLIENT_ROOT = ROOT / "src" / "Weaviate.Client" + +# Query/generate API partials (excludes TypedDataClient and other surfaces). +SCOPED_PREFIXES = ( + "QueryClient.", + "GenerateClient.", + "Typed/TypedQueryClient.", + "Typed/TypedGenerateClient.", +) + +METHOD_RE = re.compile( + r"(?P(?:[ \t]*///.*\n)+)\s*" + r"(?:(?:\s*\[[^\]]+\]\s*)*)" + r"(?Ppublic\s+(?:static\s+)?(?:async\s+)?[\w<>\[\],\.\?\s]+\s+)?" + r"(?P\w+)\s*\((?P[^)]*)\)" + r"(?:\s*where\s+[^{;]+)?\s*(?:=>|\{|;)", + re.MULTILINE, +) + + +def is_scoped(path: Path) -> bool: + rel = path.relative_to(CLIENT_ROOT).as_posix() + return any(rel.startswith(prefix) for prefix in SCOPED_PREFIXES) + + +def parse_param_names(signature: str) -> list[str]: + names: list[str] = [] + for part in signature.split(","): + part = part.strip() + if not part: + continue + part = re.sub(r"\[[^\]]*\]", "", part) + part = part.split("=")[0].strip() + part = re.sub(r"^this\s+", "", part) + tokens = part.split() + if tokens: + names.append(tokens[-1].lstrip("@")) + return names + + +def check_file(path: Path) -> list[str]: + text = path.read_text(encoding="utf-8") + rel = path.relative_to(ROOT).as_posix() + issues: list[str] = [] + + for match in METHOD_RE.finditer(text): + docs = match.group("docs") + if "" not in docs: + continue + + param_names = parse_param_names(match.group("sig")) + if not param_names: + continue + + doc_params = re.findall(r' but no tags " + f"({len(param_names)} parameters)" + ) + continue + + missing = [name for name in param_names if name not in doc_params] + extra = [name for name in doc_params if name not in param_names] + if missing: + issues.append( + f"{rel}:{line}: {method} missing for: {', '.join(missing)}" + ) + if extra: + issues.append( + f"{rel}:{line}: {method} has undocumented extra tags: " + f"{', '.join(extra)}" + ) + + return issues + + +def main() -> int: + issues: list[str] = [] + for path in sorted(CLIENT_ROOT.rglob("*.cs")): + if not is_scoped(path): + continue + issues.extend(check_file(path)) + + if not issues: + print( + "XML param docs OK for query/generate client methods " + f"({', '.join(SCOPED_PREFIXES)})" + ) + return 0 + + print(f"XML param doc check failed ({len(issues)} issue(s)):", file=sys.stderr) + for issue in issues: + print(f" {issue}", file=sys.stderr) + return 1 + + +if __name__ == "__main__": + raise SystemExit(main()) From f2f8d4ff4e223cd8244056e77eb441ce360d0e57 Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Fri, 14 Aug 2026 10:15:45 +0200 Subject: [PATCH 3/9] docs: retarget the new tags from feat/boost-query-api to main PR #358 was written against #355 (feat/boost-query-api), so its tags describe that branch's API rather than main's: - `boost` does not exist on main, so 30 `` tags document a parameter that is not there (CS1572). They belong with #355, which is the PR that introduces the parameter. - `diversitySelection` was added to the same 30 methods by #366 after this PR was written, and was left undocumented (CS1573). Drop the boost tags and document diversitySelection instead, placing each tag at the position its parameter occupies in the signature (after `bm25Operator` in the Hybrid overloads, `distance` in GenerateClient.NearVector, `offset` in the QueryClient.NearText extensions). Also align two style details the PR introduced: `` reads "The client" (26 instances repo-wide, none of "The query client"), and the two QueryClient.NearText extension blocks take the trailing period their prose-style neighbours all use. The worklist was derived from the compiler, not by hand: `dotnet build --no-incremental` now reports 0 CS1572 and 0 CS1573, and the normalized warning set is byte-identical to origin/main (55 unique warnings on both). --- src/Weaviate.Client/GenerateClient.Hybrid.cs | 12 ++++++------ src/Weaviate.Client/GenerateClient.NearVector.cs | 8 ++++---- src/Weaviate.Client/QueryClient.Hybrid.cs | 16 ++++++++-------- src/Weaviate.Client/QueryClient.NearText.cs | 12 ++++++------ .../Typed/TypedGenerateClient.Hybrid.cs | 12 ++++++------ .../Typed/TypedQueryClient.Hybrid.cs | 12 ++++++------ 6 files changed, 36 insertions(+), 36 deletions(-) diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index b833d730..41b4598e 100644 --- a/src/Weaviate.Client/GenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/GenerateClient.Hybrid.cs @@ -19,10 +19,10 @@ public partial class GenerateClient /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -89,10 +89,10 @@ public Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -173,10 +173,10 @@ public async Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -246,10 +246,10 @@ public Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -350,10 +350,10 @@ public static class GenerateClientHybridExtensions /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -425,10 +425,10 @@ await client.Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider diff --git a/src/Weaviate.Client/GenerateClient.NearVector.cs b/src/Weaviate.Client/GenerateClient.NearVector.cs index 430da230..26058fe4 100644 --- a/src/Weaviate.Client/GenerateClient.NearVector.cs +++ b/src/Weaviate.Client/GenerateClient.NearVector.cs @@ -15,11 +15,11 @@ public partial class GenerateClient /// The filters /// The certainty /// The distance + /// The diversity selection /// The auto limit /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -77,11 +77,11 @@ await _client.GrpcClient.SearchNearVector( /// The filters /// The certainty /// The distance + /// The diversity selection /// The auto limit /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -140,11 +140,11 @@ await _client.GrpcClient.SearchNearVector( /// The filters /// The certainty /// The distance + /// The diversity selection /// The auto limit /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -200,11 +200,11 @@ await NearVector( /// The filters /// The certainty /// The distance + /// The diversity selection /// The auto limit /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider diff --git a/src/Weaviate.Client/QueryClient.Hybrid.cs b/src/Weaviate.Client/QueryClient.Hybrid.cs index 0cdba080..90b84fc4 100644 --- a/src/Weaviate.Client/QueryClient.Hybrid.cs +++ b/src/Weaviate.Client/QueryClient.Hybrid.cs @@ -19,10 +19,10 @@ public partial class QueryClient /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -80,10 +80,10 @@ public Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -154,10 +154,10 @@ public async Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -218,10 +218,10 @@ public Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -301,7 +301,7 @@ public static class QueryClientHybridExtensions /// ) /// ); /// - /// The query client + /// The client /// The query /// The vectors /// The alpha @@ -311,10 +311,10 @@ public static class QueryClientHybridExtensions /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -370,7 +370,7 @@ public static async Task Hybrid( /// Performs a hybrid search (keyword + vector search) with grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// - /// The query client + /// The client /// The query /// The vectors /// The group by @@ -381,10 +381,10 @@ public static async Task Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index 35e3e8f9..ccfdb8a4 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -263,14 +263,14 @@ public static class QueryClientNearTextExtensions /// /// Performs a near-text search using a NearTextInput record. /// - /// The query client - /// The near-text input + /// The client. + /// The near-text input. /// Filters to apply to the search. /// Maximum number of results to return. /// Number of results to skip. + /// The diversity selection /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -335,15 +335,15 @@ public static async Task NearText( /// /// Performs a near-text search with group-by using a NearTextInput record. /// - /// The query client - /// The near-text input + /// The client. + /// The near-text input. /// Group-by configuration. /// Filters to apply to the search. /// Maximum number of results to return. /// Number of results to skip. + /// The diversity selection /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs index 71b156d9..9347a9ef 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs @@ -20,10 +20,10 @@ public partial class TypedGenerateClient /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -90,10 +90,10 @@ public Task> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -164,10 +164,10 @@ public async Task> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -237,10 +237,10 @@ public Task> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -321,10 +321,10 @@ public static class TypedGenerateClientHybridExtensions /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider @@ -397,10 +397,10 @@ await client.Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The single prompt /// The grouped task /// The provider diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs index 46fabf07..48dd00f1 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs @@ -20,10 +20,10 @@ public partial class TypedQueryClient /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -81,10 +81,10 @@ public Task>> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -146,10 +146,10 @@ public async Task>> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -210,10 +210,10 @@ public Task> Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -304,10 +304,10 @@ public static class TypedQueryClientHybridExtensions /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata @@ -371,10 +371,10 @@ await client.Hybrid( /// The limit /// The offset /// The bm 25 operator + /// The diversity selection /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) /// The return properties /// The return references /// The return metadata From cbd6dc3d9cc3d8fea412cd9cdf7968731cbb09fe Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Fri, 14 Aug 2026 10:16:04 +0200 Subject: [PATCH 4/9] ci: close four holes in the XML param docs gate, and stop it blocking every PR The check added in dab0af0 was weaker than the compiler and wired into preflight unconditionally. Four defects, each now covered by a self-test in ci/test_check_xml_param_docs.py: - Generic methods were invisible. `(?P\w+)\s*\(` cannot match `Hybrid(`, so the gate silently skipped 4 of the very methods this PR documents (the generic extension overloads in Typed/TypedQueryClient.Hybrid and Typed/TypedGenerateClient.Hybrid). - Unsatisfiable false positive. Splitting the parameter list on every comma turned `Dictionary filters` into a phantom parameter named `Dictionary tag can ever satisfy. Latent today; it would have wedged CI permanently the first time such a parameter appeared. - Silent success on an empty scan. Zero scanned files printed OK and exited 0, so any path drift would have disabled the gate forever. The scan count is now reported and an empty scan (or a missing client root) fails loudly. - Nested parens defeated the `[^)]*` signature capture, dropping methods with `= default(CancellationToken)`, a tuple return type, or an attribute holding parens in a string. Declarations are now located with a literal-aware brace/paren scanner instead of one regex, since a regex cannot balance those constructs. Scanned declarations rise from 118 to 126 (+4 generic overloads, +4 public constructors) with none dropped; the checker stays restricted to the public surface, as its docstring always claimed. The preflight step is also guarded on `changed-files.any_changed` like the neighbouring formatting check, and moved ahead of Setup .NET / restore since it needs no .NET. preflight is a `needs:` of the 8-version test matrix, so before this an unrelated PR touching no C# would have been blocked by it. --- .github/workflows/main.yaml | 7 +- ci/check_xml_param_docs.py | 277 +++++++++++++++++++++++++++++--- ci/test_check_xml_param_docs.py | 251 +++++++++++++++++++++++++++++ 3 files changed, 513 insertions(+), 22 deletions(-) create mode 100644 ci/test_check_xml_param_docs.py diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index e051e134..860488b3 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -77,6 +77,10 @@ jobs: files: | **.cs + - name: Check XML param docs (query/generate API) + if: steps.changed-files.outputs.any_changed == 'true' + run: python3 ci/check_xml_param_docs.py + - name: Setup .NET uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5 with: @@ -101,9 +105,6 @@ jobs: dotnet tool restore dotnet csharpier check $CHANGED_FILES - - name: Check XML param docs (query/generate API) - run: python3 ci/check_xml_param_docs.py - - name: Run analyzer unit tests run: | if [[ "${{ needs.setup.outputs.dry-run }}" == "true" ]]; then diff --git a/ci/check_xml_param_docs.py b/ci/check_xml_param_docs.py index feacd25a..8061c665 100755 --- a/ci/check_xml_param_docs.py +++ b/ci/check_xml_param_docs.py @@ -5,6 +5,11 @@ fires when the method has no doc comment at all. Methods with a and zero tags (Hybrid before this fix) slip through both. This check closes that gap for the query/generate client surface. + +Declarations are located with a small brace/paren scanner rather than a single +regex: a regex cannot balance the nested parentheses that appear in real +signatures (``= default(CancellationToken)``), in tuple return types +(``Task<(int, string)>``), or in attribute arguments. """ from __future__ import annotations @@ -24,28 +29,236 @@ "Typed/TypedGenerateClient.", ) -METHOD_RE = re.compile( - r"(?P(?:[ \t]*///.*\n)+)\s*" - r"(?:(?:\s*\[[^\]]+\]\s*)*)" - r"(?Ppublic\s+(?:static\s+)?(?:async\s+)?[\w<>\[\],\.\?\s]+\s+)?" - r"(?P\w+)\s*\((?P[^)]*)\)" - r"(?:\s*where\s+[^{;]+)?\s*(?:=>|\{|;)", - re.MULTILINE, +DOC_RUN_RE = re.compile(r"(?:[ \t]*///.*\n)+") + +# Trailing identifier of a declaration header, optionally generic: `Hybrid`. +NAME_RE = re.compile(r"(?P\w+)\s*(?P<[^<>()]*>)?\s*$") + +# A header must look like a declaration, not a random expression. +HEADER_SANITY_RE = re.compile(r"^[\w\s<>\[\],\.\?\(\):@]+$") + +# Only the public surface is in scope (private helpers may document a summary +# alone). This mirrors the `public` requirement the original regex encoded. +PUBLIC_RE = re.compile(r"\bpublic\b") + +# A method can never be named with a reserved word. Without this, the `new()` +# in a type constraint (`class Foo where T : class, new()`) parses as a +# zero-parameter method called `new`. +RESERVED_NAMES = frozenset( + { + "new", + "class", + "struct", + "record", + "interface", + "enum", + "where", + "return", + "if", + "switch", + "while", + "for", + "foreach", + "lock", + "using", + "catch", + "fixed", + "nameof", + "typeof", + "sizeof", + "default", + "base", + "this", + "get", + "set", + "init", + } ) +# How far past a doc comment we are willing to look for the `(`. +MAX_HEADER_SCAN = 800 + def is_scoped(path: Path) -> bool: rel = path.relative_to(CLIENT_ROOT).as_posix() return any(rel.startswith(prefix) for prefix in SCOPED_PREFIXES) +def _skip_literal(text: str, i: int) -> int: + """text[i] starts a string/char literal. Return the index just past it.""" + if text.startswith('@"', i): + i += 2 + while i < len(text): + if text[i] == '"': + if text.startswith('""', i): + i += 2 + continue + return i + 1 + i += 1 + return i + quote = text[i] + i += 1 + while i < len(text): + if text[i] == "\\": + i += 2 + continue + if text[i] == quote: + return i + 1 + i += 1 + return i + + +def _match_bracket(text: str, i: int, open_ch: str, close_ch: str) -> int: + """text[i] == open_ch. Return the index just past the matching close_ch. + + Literal-aware, so a bracket or paren inside a string does not unbalance it. + """ + depth = 0 + while i < len(text): + ch = text[i] + if ch in "\"'" or text.startswith('@"', i): + i = _skip_literal(text, i) + continue + if ch == open_ch: + depth += 1 + elif ch == close_ch: + depth -= 1 + if depth == 0: + return i + 1 + i += 1 + return -1 + + +def _skip_trivia_and_attributes(text: str, i: int) -> int: + """Skip whitespace, // and /* */ comments, and [attribute] blocks.""" + while i < len(text): + if text[i].isspace(): + i += 1 + elif text.startswith("//", i): + nl = text.find("\n", i) + i = len(text) if nl == -1 else nl + 1 + elif text.startswith("/*", i): + end = text.find("*/", i) + i = len(text) if end == -1 else end + 2 + elif text[i] == "[": + nxt = _match_bracket(text, i, "[", "]") + if nxt == -1: + return -1 + i = nxt + else: + return i + return i + + +def iter_declarations(text: str): + """Yield (docs, name, signature, offset) for every doc-commented declaration.""" + for run in DOC_RUN_RE.finditer(text): + docs = run.group(0) + i = _skip_trivia_and_attributes(text, run.end()) + if i == -1 or i >= len(text): + continue + + # Walk forward to the '(' that opens the parameter list. Angle brackets + # are tracked so `Task<(int, string)> Foo(` does not stop early, and a + # `;` or `{` before any '(' means this is a property/class, not a method. + j = i + angle = 0 + limit = min(len(text), i + MAX_HEADER_SCAN) + open_paren = -1 + while j < limit: + ch = text[j] + if ch in "\"'" or text.startswith('@"', j): + j = _skip_literal(text, j) + continue + if ch == "<": + angle += 1 + elif ch == ">": + angle = max(0, angle - 1) + elif ch == "(": + if angle == 0: + open_paren = j + break + # a tuple inside a generic return type: skip it wholesale + nxt = _match_bracket(text, j, "(", ")") + if nxt == -1: + break + j = nxt + continue + elif ch in ";{}" and angle == 0: + break + elif ( + angle == 0 + and text.startswith("where", j) + and not (j and (text[j - 1].isalnum() or text[j - 1] == "_")) + and not text[j + 5 : j + 6].isalnum() + ): + # A *type's* constraint clause; a method's `where` follows its + # parameter list, so reaching one first means this is a type. + break + j += 1 + + if open_paren == -1: + continue + + header = text[i:open_paren] + if not HEADER_SANITY_RE.match(header): + continue + if not PUBLIC_RE.search(header): + continue + name_match = NAME_RE.search(header) + if not name_match: + continue + + close_paren = _match_bracket(text, open_paren, "(", ")") + if close_paren == -1: + continue + sig = text[open_paren + 1 : close_paren - 1] + + # Must actually be a declaration: `where` clause, then =>, { or ; + tail = text[close_paren : close_paren + 400] + tail = re.sub(r"^\s*where\s+[^{;=]+", "", tail) + if not re.match(r"\s*(=>|\{|;)", tail): + continue + + name = name_match.group("name") + if name in RESERVED_NAMES: + continue + if name_match.group("generic"): + name += name_match.group("generic") + yield docs, name, sig, i + + +def split_top_level(signature: str) -> list[str]: + """Split a parameter list on commas that are not nested in <>, () or [].""" + parts: list[str] = [] + depth = 0 + start = 0 + i = 0 + while i < len(signature): + ch = signature[i] + if ch in "\"'" or signature.startswith('@"', i): + i = _skip_literal(signature, i) + continue + if ch in "<([": + depth += 1 + elif ch in ">)]": + depth = max(0, depth - 1) + elif ch == "," and depth == 0: + parts.append(signature[start:i]) + start = i + 1 + i += 1 + parts.append(signature[start:]) + return parts + + def parse_param_names(signature: str) -> list[str]: names: list[str] = [] - for part in signature.split(","): + for part in split_top_level(signature): part = part.strip() if not part: continue part = re.sub(r"\[[^\]]*\]", "", part) + # Drop the default value; `= default(CancellationToken)` may hold a comma. part = part.split("=")[0].strip() part = re.sub(r"^this\s+", "", part) tokens = part.split() @@ -54,23 +267,23 @@ def parse_param_names(signature: str) -> list[str]: return names -def check_file(path: Path) -> list[str]: +def check_file(path: Path) -> tuple[list[str], int]: text = path.read_text(encoding="utf-8") rel = path.relative_to(ROOT).as_posix() issues: list[str] = [] + scanned = 0 - for match in METHOD_RE.finditer(text): - docs = match.group("docs") + for docs, method, sig, offset in iter_declarations(text): + scanned += 1 if "" not in docs: continue - param_names = parse_param_names(match.group("sig")) + param_names = parse_param_names(sig) if not param_names: continue doc_params = re.findall(r' list[str]: f"{', '.join(extra)}" ) - return issues + return issues, scanned def main() -> int: + if not CLIENT_ROOT.is_dir(): + print( + f"XML param doc check failed: client root not found at {CLIENT_ROOT}", + file=sys.stderr, + ) + return 1 + issues: list[str] = [] + files_scanned = 0 + declarations = 0 for path in sorted(CLIENT_ROOT.rglob("*.cs")): if not is_scoped(path): continue - issues.extend(check_file(path)) + files_scanned += 1 + file_issues, scanned = check_file(path) + issues.extend(file_issues) + declarations += scanned + + # A path/layout drift must fail loudly rather than silently pass forever. + if files_scanned == 0: + print( + "XML param doc check failed: scanned 0 files under " + f"{CLIENT_ROOT} matching {', '.join(SCOPED_PREFIXES)}. " + "The check is misconfigured (did the layout move?).", + file=sys.stderr, + ) + return 1 if not issues: print( - "XML param docs OK for query/generate client methods " - f"({', '.join(SCOPED_PREFIXES)})" + f"XML param docs OK: {declarations} declaration(s) in " + f"{files_scanned} file(s) matching {', '.join(SCOPED_PREFIXES)}" ) return 0 - print(f"XML param doc check failed ({len(issues)} issue(s)):", file=sys.stderr) + print( + f"XML param doc check failed ({len(issues)} issue(s) across " + f"{declarations} declaration(s) in {files_scanned} file(s)):", + file=sys.stderr, + ) for issue in issues: print(f" {issue}", file=sys.stderr) return 1 diff --git a/ci/test_check_xml_param_docs.py b/ci/test_check_xml_param_docs.py new file mode 100644 index 00000000..9a2848fe --- /dev/null +++ b/ci/test_check_xml_param_docs.py @@ -0,0 +1,251 @@ +#!/usr/bin/env python3 +"""Self-tests for check_xml_param_docs.py. + +Dependency-free (no pytest in this repo): run with `python3 ci/test_check_xml_param_docs.py`. +Each case pins one of the defects the checker previously had. +""" + +from __future__ import annotations + +import importlib.util +import io +import re +import sys +import tempfile +from contextlib import redirect_stderr, redirect_stdout +from pathlib import Path + +HERE = Path(__file__).resolve().parent +spec = importlib.util.spec_from_file_location("chk", HERE / "check_xml_param_docs.py") +chk = importlib.util.module_from_spec(spec) +spec.loader.exec_module(chk) + +FAILURES: list[str] = [] + + +def check(label: str, condition: bool, detail: str = "") -> None: + if condition: + print(f" PASS {label}") + else: + print(f" FAIL {label}{(': ' + detail) if detail else ''}") + FAILURES.append(label) + + +def decls(source: str): + return list(chk.iter_declarations(source)) + + +# ---------------------------------------------------------------- defect 1 +# Generic methods were invisible: `(?P\w+)\s*\(` cannot match `Hybrid(`. +GENERIC_SRC = """ +public static class Ext +{ + /// + /// Performs a hybrid search. + /// + /// The client + public static Task Hybrid(this Client client, string query) + { + return null; + } +} +""" + + +def test_generic_methods() -> None: + print("defect 1 - generic methods are scanned") + found = decls(GENERIC_SRC) + names = [d[1] for d in found] + check("Hybrid is discovered", "Hybrid" in names, f"got {names}") + # and, being discovered, its missing param is reported + with tempfile.TemporaryDirectory() as td: + p = Path(td) / "QueryClient.Generic.cs" + p.write_text(GENERIC_SRC, encoding="utf-8") + old_root, chk.ROOT = chk.ROOT, Path(td) + issues, scanned = chk.check_file(p) + chk.ROOT = old_root + check( + "undocumented 'query' on the generic overload is reported", + any("missing for: query" in i for i in issues), + f"got {issues}", + ) + + +# ---------------------------------------------------------------- defect 2 +# Splitting the parameter list on every comma turned `Dictionary` +# into a phantom parameter named `Dictionary None: + print("defect 2 - commas inside generic type arguments") + names = chk.parse_param_names( + "Dictionary filters, IList> pairs, int limit" + ) + check( + "generic args do not create phantom parameters", + names == ["filters", "pairs", "limit"], + f"got {names}", + ) + check( + "no phantom 'Dictionary None: + print("defect 3 - an empty scan fails loudly") + with tempfile.TemporaryDirectory() as td: + empty = Path(td) / "src" / "Weaviate.Client" + empty.mkdir(parents=True) + old_root, old_client = chk.ROOT, chk.CLIENT_ROOT + chk.ROOT, chk.CLIENT_ROOT = Path(td), empty + err = io.StringIO() + with redirect_stdout(io.StringIO()), redirect_stderr(err): + rc = chk.main() + chk.ROOT, chk.CLIENT_ROOT = old_root, old_client + check("exit code is non-zero when 0 files are scanned", rc != 0, f"rc={rc}") + check( + "message explains the misconfiguration", + "scanned 0 files" in err.getvalue(), + f"stderr={err.getvalue()!r}", + ) + + +def test_missing_client_root_fails() -> None: + print("defect 3b - a missing client root fails loudly") + with tempfile.TemporaryDirectory() as td: + old_root, old_client = chk.ROOT, chk.CLIENT_ROOT + chk.ROOT, chk.CLIENT_ROOT = Path(td), Path(td) / "does" / "not" / "exist" + err = io.StringIO() + with redirect_stdout(io.StringIO()), redirect_stderr(err): + rc = chk.main() + chk.ROOT, chk.CLIENT_ROOT = old_root, old_client + check("exit code is non-zero when the client root is absent", rc != 0, f"rc={rc}") + check( + "message names the missing root", + "client root not found" in err.getvalue(), + f"stderr={err.getvalue()!r}", + ) + + +# ---------------------------------------------------------------- defect 4 +# Nested parens in a default value, a tuple return type, and parens/brackets +# inside an attribute string all defeated the `[^)]*` signature capture. +NESTED_SRC = """ +public class C +{ + /// Does a thing. + /// The query + /// The cancellation token + public Task WithDefaultParen( + string query, + CancellationToken cancellationToken = default(CancellationToken) + ) + { + return null; + } + + /// Does a thing. + /// The query + public Task<(int Count, string Name)> WithTupleReturn(string query) + { + return null; + } + + /// Does a thing. + /// The query + [Obsolete("use Other(x) instead [see docs]")] + public Task WithTrickyAttribute(string query) + { + return null; + } +} +""" + + +def test_nested_parens_and_attributes() -> None: + print("defect 4 - nested parens, tuple returns, tricky attributes") + found = {d[1]: d[2] for d in decls(NESTED_SRC)} + check( + "method with `= default(CancellationToken)` is scanned", + "WithDefaultParen" in found, + f"got {sorted(found)}", + ) + if "WithDefaultParen" in found: + names = chk.parse_param_names(found["WithDefaultParen"]) + check( + "its parameters parse correctly", + names == ["query", "cancellationToken"], + f"got {names}", + ) + check( + "method with a tuple return type is scanned", + "WithTupleReturn" in found, + f"got {sorted(found)}", + ) + check( + "method behind an attribute containing parens/brackets in a string is scanned", + "WithTrickyAttribute" in found, + f"got {sorted(found)}", + ) + + +# ------------------------------------------------- regression: no bad parses +TYPE_CONSTRAINT_SRC = """ +/// +/// The typed query client +/// +public partial class TypedQueryClient + where T : class, new() +{ +} +""" + + +def test_type_constraint_is_not_a_method() -> None: + print("regression - a type's `where T : class, new()` is not a method") + names = [d[1] for d in decls(TYPE_CONSTRAINT_SRC)] + check("no phantom `new` declaration", "new" not in names, f"got {names}") + + +def test_real_tree_is_clean() -> None: + print("integration - the real client tree passes") + out = io.StringIO() + with redirect_stdout(out), redirect_stderr(out): + rc = chk.main() + text = out.getvalue().strip() + check("checker exits 0 on the current tree", rc == 0, text) + m = re.search(r"(\d+) declaration\(s\) in (\d+) file\(s\)", text) + check("it reports what it scanned", m is not None, text) + if m: + check( + "it scanned a non-trivial number of declarations", + int(m.group(1)) > 100 and int(m.group(2)) > 10, + text, + ) + print(f" -> {m.group(1)} declarations in {m.group(2)} files") + + +def main() -> int: + for fn in ( + test_generic_methods, + test_generic_parameter_types, + test_empty_scan_fails, + test_missing_client_root_fails, + test_nested_parens_and_attributes, + test_type_constraint_is_not_a_method, + test_real_tree_is_clean, + ): + fn() + print() + if FAILURES: + print(f"FAILED ({len(FAILURES)}): {', '.join(FAILURES)}") + return 1 + print("all self-tests passed") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) From da85f567ca80b47dad73dfbf0944a70436e3a18b Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Fri, 14 Aug 2026 10:22:21 +0200 Subject: [PATCH 5/9] docs+ci: match the prose wording convention, run the self-test, type-clean it Three follow-ups on the review of the previous two commits. Use the prose wording in the two prose-style blocks. The `diversitySelection` wording on main is block-sensitive, not global: terse blocks say "The diversity selection" (28 instances) and prose blocks say "Diversity selection to apply to the results." (50 instances), and every one of the 77 pre-existing instances matches its block. The two tags added to the QueryClient.NearText extension overloads sat in prose blocks, so they now take the prose wording; the other 28 this PR adds are in terse blocks and are unchanged. The convention now holds across all 107 instances with no exceptions. Run the self-test in CI. A test nobody runs is not a test, so the guarded preflight step now runs ci/test_check_xml_param_docs.py before the checker itself. Both are plain commands on separate lines, so the runner's `bash -e` propagates a failure: with a deliberately reverted generics fix the step exits 1 and never reaches the checker. Make both files type-clean. Pyright reported 13 errors in the new test, all stemming from monkey-patching module globals and from using the `ModuleSpec | None` returned by spec_from_file_location unguarded. Rather than suppressing them, `check_file` and `main` now take their roots as parameters defaulting to the module constants, so the test injects roots instead of patching them, and the spec and its loader are asserted non-None. Both files report 0 errors, and the checker's standalone behaviour is unchanged. --- .github/workflows/main.yaml | 4 +++- ci/check_xml_param_docs.py | 23 +++++++++++---------- ci/test_check_xml_param_docs.py | 23 ++++++++------------- src/Weaviate.Client/QueryClient.NearText.cs | 4 ++-- 4 files changed, 26 insertions(+), 28 deletions(-) diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index 860488b3..05449999 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -79,7 +79,9 @@ jobs: - name: Check XML param docs (query/generate API) if: steps.changed-files.outputs.any_changed == 'true' - run: python3 ci/check_xml_param_docs.py + run: | + python3 ci/test_check_xml_param_docs.py + python3 ci/check_xml_param_docs.py - name: Setup .NET uses: actions/setup-dotnet@c2fa09f4bde5ebb9d1777cf28262a3eb3db3ced7 # v5 diff --git a/ci/check_xml_param_docs.py b/ci/check_xml_param_docs.py index 8061c665..0a717166 100755 --- a/ci/check_xml_param_docs.py +++ b/ci/check_xml_param_docs.py @@ -79,8 +79,8 @@ MAX_HEADER_SCAN = 800 -def is_scoped(path: Path) -> bool: - rel = path.relative_to(CLIENT_ROOT).as_posix() +def is_scoped(path: Path, client_root: Path = CLIENT_ROOT) -> bool: + rel = path.relative_to(client_root).as_posix() return any(rel.startswith(prefix) for prefix in SCOPED_PREFIXES) @@ -267,9 +267,9 @@ def parse_param_names(signature: str) -> list[str]: return names -def check_file(path: Path) -> tuple[list[str], int]: +def check_file(path: Path, root: Path = ROOT) -> tuple[list[str], int]: text = path.read_text(encoding="utf-8") - rel = path.relative_to(ROOT).as_posix() + rel = path.relative_to(root).as_posix() issues: list[str] = [] scanned = 0 @@ -307,10 +307,11 @@ def check_file(path: Path) -> tuple[list[str], int]: return issues, scanned -def main() -> int: - if not CLIENT_ROOT.is_dir(): +def main(root: Path = ROOT, client_root: Path = CLIENT_ROOT) -> int: + """Run the check. Roots are injectable so tests need not patch globals.""" + if not client_root.is_dir(): print( - f"XML param doc check failed: client root not found at {CLIENT_ROOT}", + f"XML param doc check failed: client root not found at {client_root}", file=sys.stderr, ) return 1 @@ -318,11 +319,11 @@ def main() -> int: issues: list[str] = [] files_scanned = 0 declarations = 0 - for path in sorted(CLIENT_ROOT.rglob("*.cs")): - if not is_scoped(path): + for path in sorted(client_root.rglob("*.cs")): + if not is_scoped(path, client_root): continue files_scanned += 1 - file_issues, scanned = check_file(path) + file_issues, scanned = check_file(path, root) issues.extend(file_issues) declarations += scanned @@ -330,7 +331,7 @@ def main() -> int: if files_scanned == 0: print( "XML param doc check failed: scanned 0 files under " - f"{CLIENT_ROOT} matching {', '.join(SCOPED_PREFIXES)}. " + f"{client_root} matching {', '.join(SCOPED_PREFIXES)}. " "The check is misconfigured (did the layout move?).", file=sys.stderr, ) diff --git a/ci/test_check_xml_param_docs.py b/ci/test_check_xml_param_docs.py index 9a2848fe..339063d5 100644 --- a/ci/test_check_xml_param_docs.py +++ b/ci/test_check_xml_param_docs.py @@ -16,9 +16,12 @@ from pathlib import Path HERE = Path(__file__).resolve().parent -spec = importlib.util.spec_from_file_location("chk", HERE / "check_xml_param_docs.py") -chk = importlib.util.module_from_spec(spec) -spec.loader.exec_module(chk) + +_spec = importlib.util.spec_from_file_location("chk", HERE / "check_xml_param_docs.py") +assert _spec is not None, "could not build a module spec for check_xml_param_docs.py" +assert _spec.loader is not None, "module spec for check_xml_param_docs.py has no loader" +chk = importlib.util.module_from_spec(_spec) +_spec.loader.exec_module(chk) FAILURES: list[str] = [] @@ -61,9 +64,7 @@ def test_generic_methods() -> None: with tempfile.TemporaryDirectory() as td: p = Path(td) / "QueryClient.Generic.cs" p.write_text(GENERIC_SRC, encoding="utf-8") - old_root, chk.ROOT = chk.ROOT, Path(td) - issues, scanned = chk.check_file(p) - chk.ROOT = old_root + issues, _scanned = chk.check_file(p, root=Path(td)) check( "undocumented 'query' on the generic overload is reported", any("missing for: query" in i for i in issues), @@ -99,12 +100,9 @@ def test_empty_scan_fails() -> None: with tempfile.TemporaryDirectory() as td: empty = Path(td) / "src" / "Weaviate.Client" empty.mkdir(parents=True) - old_root, old_client = chk.ROOT, chk.CLIENT_ROOT - chk.ROOT, chk.CLIENT_ROOT = Path(td), empty err = io.StringIO() with redirect_stdout(io.StringIO()), redirect_stderr(err): - rc = chk.main() - chk.ROOT, chk.CLIENT_ROOT = old_root, old_client + rc = chk.main(root=Path(td), client_root=empty) check("exit code is non-zero when 0 files are scanned", rc != 0, f"rc={rc}") check( "message explains the misconfiguration", @@ -116,12 +114,9 @@ def test_empty_scan_fails() -> None: def test_missing_client_root_fails() -> None: print("defect 3b - a missing client root fails loudly") with tempfile.TemporaryDirectory() as td: - old_root, old_client = chk.ROOT, chk.CLIENT_ROOT - chk.ROOT, chk.CLIENT_ROOT = Path(td), Path(td) / "does" / "not" / "exist" err = io.StringIO() with redirect_stdout(io.StringIO()), redirect_stderr(err): - rc = chk.main() - chk.ROOT, chk.CLIENT_ROOT = old_root, old_client + rc = chk.main(root=Path(td), client_root=Path(td) / "does" / "not" / "exist") check("exit code is non-zero when the client root is absent", rc != 0, f"rc={rc}") check( "message names the missing root", diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index ccfdb8a4..bd1b8cb8 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -268,7 +268,7 @@ public static class QueryClientNearTextExtensions /// Filters to apply to the search. /// Maximum number of results to return. /// Number of results to skip. - /// The diversity selection + /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. /// Properties to return in the response. @@ -341,7 +341,7 @@ public static async Task NearText( /// Filters to apply to the search. /// Maximum number of results to return. /// Number of results to skip. - /// The diversity selection + /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. /// Properties to return in the response. From ef28801136973ce2bb42c3f5df5efcdcd3934161 Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Fri, 14 Aug 2026 10:40:13 +0200 Subject: [PATCH 6/9] test: drop the unused sys import, and make the scanned count earn its place MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two lint leftovers from the roots-injection refactor. `sys` became unused once the tests stopped writing to stderr directly, so remove it. The `_scanned` return from check_file was discarded; rather than dropping it, assert on it — the generic fixture holds exactly one declaration, so it now pins that the generic overload is counted rather than merely parsed. 18 self-tests pass; ruff and pyright both report clean. --- ci/test_check_xml_param_docs.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/ci/test_check_xml_param_docs.py b/ci/test_check_xml_param_docs.py index 339063d5..7944b821 100644 --- a/ci/test_check_xml_param_docs.py +++ b/ci/test_check_xml_param_docs.py @@ -10,7 +10,6 @@ import importlib.util import io import re -import sys import tempfile from contextlib import redirect_stderr, redirect_stdout from pathlib import Path @@ -64,7 +63,12 @@ def test_generic_methods() -> None: with tempfile.TemporaryDirectory() as td: p = Path(td) / "QueryClient.Generic.cs" p.write_text(GENERIC_SRC, encoding="utf-8") - issues, _scanned = chk.check_file(p, root=Path(td)) + issues, scanned = chk.check_file(p, root=Path(td)) + check( + "the generic overload is the one declaration counted in the file", + scanned == 1, + f"got {scanned}", + ) check( "undocumented 'query' on the generic overload is reported", any("missing for: query" in i for i in issues), From 4a917979c895da44890bda7c8753a5c691272a3d Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Tue, 18 Aug 2026 14:09:04 +0200 Subject: [PATCH 7/9] docs: describe the query and generate parameters, and correct alpha MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The param text restated the parameter name — "The alpha", "The bm 25 operator" — so it carried less than the signature already showed. Each parameter now says what it does and what happens when it is left unset, which for a nullable parameter is usually the half that matters. alpha is corrected rather than matched to the Python client, which calls it the weight of the BM25 score. Core weights the dense result set by alpha and the sparse one by 1 - alpha, so 0.0 is pure keyword and 1.0 is pure vector, and the server default is 0.75. The client also sets alpha to 1.0 itself when no query text is given, which the text now mentions. provider is corrected too: passing one when the prompt already carries a provider throws rather than being ignored. The same wording is still wrong in the files this change does not touch. --- src/Weaviate.Client/GenerateClient.Hybrid.cs | 258 +++++++++--------- .../GenerateClient.NearVector.cs | 244 ++++++++--------- src/Weaviate.Client/QueryClient.Hybrid.cs | 222 +++++++-------- src/Weaviate.Client/QueryClient.NearText.cs | 132 ++++----- .../Typed/TypedGenerateClient.Hybrid.cs | 258 +++++++++--------- .../Typed/TypedQueryClient.Hybrid.cs | 222 +++++++-------- 6 files changed, 668 insertions(+), 668 deletions(-) diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index 41b4598e..460436c7 100644 --- a/src/Weaviate.Client/GenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/GenerateClient.Hybrid.cs @@ -11,26 +11,26 @@ public partial class GenerateClient /// /// Hybrid search with generative AI capabilities. /// - /// The query - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task Hybrid( string query, float? alpha = null, @@ -80,27 +80,27 @@ public Task Hybrid( /// /// Hybrid search with generative AI capabilities. /// - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -164,27 +164,27 @@ public async Task Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// - /// The query - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task Hybrid( string query, GroupByRequest groupBy, @@ -236,28 +236,28 @@ public Task Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -340,28 +340,28 @@ public static class GenerateClientHybridExtensions /// singlePrompt: "Describe this item" /// ); /// - /// The client - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task Hybrid( this GenerateClient client, string query, @@ -414,29 +414,29 @@ await client.Hybrid( /// Hybrid search with generative AI capabilities and grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// - /// The client - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task Hybrid( this GenerateClient client, string query, diff --git a/src/Weaviate.Client/GenerateClient.NearVector.cs b/src/Weaviate.Client/GenerateClient.NearVector.cs index 26058fe4..744bada2 100644 --- a/src/Weaviate.Client/GenerateClient.NearVector.cs +++ b/src/Weaviate.Client/GenerateClient.NearVector.cs @@ -11,23 +11,23 @@ public partial class GenerateClient /// /// Search near vector with generative AI capabilities. /// - /// The vectors - /// The filters - /// The certainty - /// The distance - /// The diversity selection - /// The auto limit - /// The limit - /// The offset - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The vector or named vectors to search near. + /// Filters to apply to the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task NearVector( VectorSearchInput vectors, Filter? filters = null, @@ -72,24 +72,24 @@ await _client.GrpcClient.SearchNearVector( /// /// Search near vector with generative AI capabilities and grouping. /// - /// The vectors - /// The group by - /// The filters - /// The certainty - /// The distance - /// The diversity selection - /// The auto limit - /// The limit - /// The offset - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The vector or named vectors to search near. + /// Group-by configuration. + /// Filters to apply to the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task NearVector( VectorSearchInput vectors, GroupByRequest groupBy, @@ -136,23 +136,23 @@ await _client.GrpcClient.SearchNearVector( /// /// Search near vector with generative AI capabilities using lambda builder. /// - /// The vectors - /// The filters - /// The certainty - /// The distance - /// The diversity selection - /// The auto limit - /// The limit - /// The offset - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Lambda builder for the vector input to search near. + /// Filters to apply to the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task NearVector( VectorSearchInput.FactoryFn vectors, Filter? filters = null, @@ -195,24 +195,24 @@ await NearVector( /// /// Search near vector with generative AI capabilities and grouping using lambda builder. /// - /// The vectors - /// The group by - /// The filters - /// The certainty - /// The distance - /// The diversity selection - /// The auto limit - /// The limit - /// The offset - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Lambda builder for the vector input to search near. + /// Group-by configuration. + /// Filters to apply to the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task NearVector( VectorSearchInput.FactoryFn vectors, GroupByRequest groupBy, @@ -259,19 +259,19 @@ await NearVector( /// /// Near-vector input containing vector, certainty, and distance. /// Filters to apply to the search. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Maximum number of results to return. - /// Number of results to skip. - /// Re-ranking configuration. - /// Single prompt for generative AI. - /// Grouped task for generative AI. - /// Generative AI provider configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Generative search results. public async Task NearVector( NearVectorInput query, @@ -316,19 +316,19 @@ await NearVector( /// Near-vector input containing vector, certainty, and distance. /// Group-by configuration. /// Filters to apply to the search. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Maximum number of results to return. - /// Number of results to skip. - /// Re-ranking configuration. - /// Single prompt for generative AI. - /// Grouped task for generative AI. - /// Generative AI provider configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Generative grouped search results. public async Task NearVector( NearVectorInput query, @@ -374,19 +374,19 @@ await NearVector( /// /// /// Filters to apply to the search. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Maximum number of results to return. - /// Number of results to skip. - /// Re-ranking configuration. - /// Single prompt for generative AI. - /// Grouped task for generative AI. - /// Generative AI provider configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Generative search results. public async Task NearVector( NearVectorInput.FactoryFn vectors, @@ -429,19 +429,19 @@ await NearVector( /// /// Group-by configuration. /// Filters to apply to the search. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Maximum number of results to return. - /// Number of results to skip. - /// Re-ranking configuration. - /// Single prompt for generative AI. - /// Grouped task for generative AI. - /// Generative AI provider configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Generative grouped search results. public async Task NearVector( NearVectorInput.FactoryFn vectors, diff --git a/src/Weaviate.Client/QueryClient.Hybrid.cs b/src/Weaviate.Client/QueryClient.Hybrid.cs index 90b84fc4..3ede431a 100644 --- a/src/Weaviate.Client/QueryClient.Hybrid.cs +++ b/src/Weaviate.Client/QueryClient.Hybrid.cs @@ -11,23 +11,23 @@ public partial class QueryClient /// /// Performs a hybrid search (keyword + vector search). /// - /// The query - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task Hybrid( string query, float? alpha = null, @@ -71,24 +71,24 @@ public Task Hybrid( /// /// Performs a hybrid search (keyword + vector search). /// - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -145,24 +145,24 @@ public async Task Hybrid( /// /// Performs a hybrid search (keyword + vector search) with grouping. /// - /// The query - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task Hybrid( string query, GroupByRequest groupBy, @@ -208,25 +208,25 @@ public Task Hybrid( /// /// Performs a hybrid search (keyword + vector search) with grouping. /// - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task Hybrid( string? query, HybridVectorInput? vectors, @@ -301,25 +301,25 @@ public static class QueryClientHybridExtensions /// ) /// ); /// - /// The client - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task Hybrid( this QueryClient client, string? query = null, @@ -370,26 +370,26 @@ public static async Task Hybrid( /// Performs a hybrid search (keyword + vector search) with grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// - /// The client - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task Hybrid( this QueryClient client, string? query, diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index bd1b8cb8..45f727b0 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -10,21 +10,21 @@ public partial class QueryClient { /// Performs a near-text search using the specified parameters. /// The search text. - /// Certainty threshold for the search. - /// Distance threshold for the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. /// Move-to configuration. /// Move-away configuration. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Search results. public async Task NearText( AutoArray query, @@ -70,21 +70,21 @@ await _grpc.SearchNearText( /// Performs a near-text search with group-by using the specified parameters. /// The search text. /// Group-by configuration. - /// Certainty threshold for the search. - /// Distance threshold for the search. + /// Certainty threshold for the search: the minimum similarity a result must reach. If not specified, no threshold is applied. + /// Distance threshold for the search: the maximum distance a result may have from the query vector. If not specified, no threshold is applied. /// Move-to configuration. /// Move-away configuration. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Grouped search results. public async Task NearText( AutoArray query, @@ -143,16 +143,16 @@ await _grpc.SearchNearText( /// /// Lambda builder for creating NearTextInput with target vectors. /// Filters to apply to the search. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Search results. public async Task NearText( NearTextInput.FactoryFn query, @@ -201,16 +201,16 @@ public async Task NearText( /// Lambda builder for creating NearTextInput with target vectors. /// Group-by configuration. /// Filters to apply to the search. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. /// Grouped search results. public async Task NearText( NearTextInput.FactoryFn query, @@ -263,19 +263,19 @@ public static class QueryClientNearTextExtensions /// /// Performs a near-text search using a NearTextInput record. /// - /// The client. + /// The client to run the search on. /// The near-text input. /// Filters to apply to the search. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task NearText( this QueryClient client, NearTextInput query, @@ -335,20 +335,20 @@ public static async Task NearText( /// /// Performs a near-text search with group-by using a NearTextInput record. /// - /// The client. + /// The client to run the search on. /// The near-text input. /// Group-by configuration. /// Filters to apply to the search. - /// Maximum number of results to return. - /// Number of results to skip. - /// Diversity selection to apply to the results. - /// Automatic result cutoff threshold. - /// Re-ranking configuration. - /// Properties to return in the response. - /// Cross-references to return. - /// Metadata to include in the response. - /// Vector configuration for returned objects. - /// Cancellation token. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task NearText( this QueryClient client, NearTextInput query, diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs index 9347a9ef..c65c6cbb 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs @@ -12,26 +12,26 @@ public partial class TypedGenerateClient /// /// Hybrid search with generative AI capabilities (query-only, no vectors). /// - /// The query - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task> Hybrid( string query, float? alpha = null, @@ -81,27 +81,27 @@ public Task> Hybrid( /// /// Hybrid search with generative AI capabilities. /// - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -155,27 +155,27 @@ public async Task> Hybrid( /// /// Hybrid search with generative AI capabilities and grouping (query-only, no vectors). /// - /// The query - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task> Hybrid( string query, GroupByRequest groupBy, @@ -227,28 +227,28 @@ public Task> Hybrid( /// /// Hybrid search with generative AI capabilities and grouping. /// - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -311,28 +311,28 @@ public static class TypedGenerateClientHybridExtensions /// Hybrid search with generative AI capabilities using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// - /// The client - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task> Hybrid( this TypedGenerateClient client, string query, @@ -386,29 +386,29 @@ await client.Hybrid( /// Hybrid search with generative AI capabilities and grouping using a lambda to build HybridVectorInput. /// This allows chaining NearVector or NearText configuration with target vectors. /// - /// The client - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The single prompt - /// The grouped task - /// The provider - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. + /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. + /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task> Hybrid( this TypedGenerateClient client, string query, diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs index 48dd00f1..07c071dc 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs @@ -12,23 +12,23 @@ public partial class TypedQueryClient /// /// Performs a hybrid search using keyword search only. /// - /// The query - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task>> Hybrid( string query, float? alpha = null, @@ -72,24 +72,24 @@ public Task>> Hybrid( /// /// Performs a hybrid search combining keyword and vector search. /// - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task>> Hybrid( string? query, HybridVectorInput? vectors, @@ -137,24 +137,24 @@ public async Task>> Hybrid( /// /// Performs a hybrid search with group-by aggregation using keyword search only. /// - /// The query - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public Task> Hybrid( string query, GroupByRequest groupBy, @@ -200,25 +200,25 @@ public Task> Hybrid( /// /// Performs a hybrid search with group-by aggregation. /// - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// Text query for the keyword (BM25) half of the search. + /// Vector input for the vector half of the search. If not specified, the query text is vectorized and used. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public async Task> Hybrid( string? query, HybridVectorInput? vectors, @@ -294,25 +294,25 @@ public static class TypedQueryClientHybridExtensions /// ) /// ); /// - /// The client - /// The query - /// The vectors - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task>> Hybrid( this TypedQueryClient client, string query, @@ -360,26 +360,26 @@ await client.Hybrid( /// Performs a hybrid search (keyword + vector search) with grouping using a lambda to build HybridVectorInput. /// Supports NearVector, NearText, or direct vector input via .Vectors(). /// - /// The client - /// The query - /// The vectors - /// The group by - /// The alpha - /// The query properties - /// The fusion type - /// The max vector distance - /// The limit - /// The offset - /// The bm 25 operator - /// The diversity selection - /// The auto limit - /// The filters - /// The rerank - /// The return properties - /// The return references - /// The return metadata - /// The include vectors - /// The cancellation token + /// The client to run the search on. + /// Text query for the keyword (BM25) half of the search. + /// Lambda builder for the vector input used by the vector half of the search. + /// Group-by configuration. + /// Balance between the keyword and the vector half of the search: 0.0 is pure keyword (BM25), 1.0 is pure vector. If not specified, the server default of 0.75 is used, or 1.0 when no query text is given. + /// Properties the keyword (BM25) half of the search runs against. If not specified, all text properties are searched. + /// How the keyword and vector result sets are fused: Ranked adds inverted ranks, RelativeScore adds normalized scores. If not specified, the server default (RelativeScore) is used. + /// Maximum distance allowed for the vector half of the search. If not specified, no distance threshold is applied. + /// Maximum number of results to return. If not specified, the server default limit is used. + /// Number of results to skip. If not specified, results start from the first object. + /// Operator for the keyword (BM25) half of the search, setting how many query tokens a property must match. If not specified, the server default (Or) is used. + /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. + /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. + /// Filters to apply to the search. + /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Properties to return in the response. If not specified, all non-blob properties are returned. + /// Cross-references to return. If not specified, no references are returned. + /// Metadata to include in the response. If not specified, no metadata is returned. + /// Vector configuration for returned objects. If not specified, no vectors are returned. + /// The cancellation token to monitor for cancellation requests. public static async Task> Hybrid( this TypedQueryClient client, string query, From 4a3d9c41ff51a508778da92cfad44fd057c1342b Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Tue, 18 Aug 2026 14:23:13 +0200 Subject: [PATCH 8/9] docs: describe the boost parameter on every query and generate method MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The XML param gate this branch adds requires a tag for every parameter of a documented public method. main documents boost on some of the methods that took it in #355 and not on others, so the six Hybrid, NearText and NearVector partials were left with 30 undocumented boost parameters — the branch's own check would have failed on main's code. Every boost parameter now carries the same description, taken from the summary on Boost itself: it re-scores the candidate pool the search fetches rather than excluding anything, nothing is boosted when it is left unset, and a server older than 1.38 ignores it silently. That last point is the one a caller cannot otherwise see, since the query still succeeds and only the ranking is wrong. 106 tags across 24 files, replacing the 68 shorter ones main carried. --- src/Weaviate.Client/GenerateClient.BM25.cs | 4 ++-- src/Weaviate.Client/GenerateClient.Hybrid.cs | 6 ++++++ src/Weaviate.Client/GenerateClient.NearMedia.cs | 4 ++-- src/Weaviate.Client/GenerateClient.NearObject.cs | 4 ++-- src/Weaviate.Client/GenerateClient.NearText.cs | 12 ++++++------ src/Weaviate.Client/GenerateClient.NearVector.cs | 4 ++++ src/Weaviate.Client/QueryClient.BM25.cs | 4 ++-- src/Weaviate.Client/QueryClient.Hybrid.cs | 6 ++++++ src/Weaviate.Client/QueryClient.NearMedia.cs | 8 ++++---- src/Weaviate.Client/QueryClient.NearObject.cs | 4 ++-- src/Weaviate.Client/QueryClient.NearText.cs | 2 ++ src/Weaviate.Client/QueryClient.NearVector.cs | 16 ++++++++-------- .../Typed/TypedGenerateClient.BM25.cs | 4 ++-- .../Typed/TypedGenerateClient.Hybrid.cs | 6 ++++++ .../Typed/TypedGenerateClient.NearMedia.cs | 4 ++-- .../Typed/TypedGenerateClient.NearObject.cs | 4 ++-- .../Typed/TypedGenerateClient.NearText.cs | 12 ++++++------ .../Typed/TypedGenerateClient.NearVector.cs | 16 ++++++++-------- .../Typed/TypedQueryClient.BM25.cs | 4 ++-- .../Typed/TypedQueryClient.Hybrid.cs | 6 ++++++ .../Typed/TypedQueryClient.NearMedia.cs | 4 ++-- .../Typed/TypedQueryClient.NearObject.cs | 4 ++-- .../Typed/TypedQueryClient.NearText.cs | 12 ++++++------ .../Typed/TypedQueryClient.NearVector.cs | 16 ++++++++-------- 24 files changed, 98 insertions(+), 68 deletions(-) diff --git a/src/Weaviate.Client/GenerateClient.BM25.cs b/src/Weaviate.Client/GenerateClient.BM25.cs index 5d321cb5..e1b99bb4 100644 --- a/src/Weaviate.Client/GenerateClient.BM25.cs +++ b/src/Weaviate.Client/GenerateClient.BM25.cs @@ -20,7 +20,7 @@ public partial class GenerateClient /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -92,7 +92,7 @@ public async Task BM25( /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index 0ee25d9f..69f592a4 100644 --- a/src/Weaviate.Client/GenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/GenerateClient.Hybrid.cs @@ -23,6 +23,7 @@ public partial class GenerateClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -95,6 +96,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -181,6 +183,7 @@ public async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -256,6 +259,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -362,6 +366,7 @@ public static class GenerateClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -439,6 +444,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/GenerateClient.NearMedia.cs b/src/Weaviate.Client/GenerateClient.NearMedia.cs index fbe6c570..b17192cc 100644 --- a/src/Weaviate.Client/GenerateClient.NearMedia.cs +++ b/src/Weaviate.Client/GenerateClient.NearMedia.cs @@ -31,7 +31,7 @@ public partial class GenerateClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -109,7 +109,7 @@ public async Task NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/GenerateClient.NearObject.cs b/src/Weaviate.Client/GenerateClient.NearObject.cs index d8ea4524..2dbc8279 100644 --- a/src/Weaviate.Client/GenerateClient.NearObject.cs +++ b/src/Weaviate.Client/GenerateClient.NearObject.cs @@ -20,7 +20,7 @@ public partial class GenerateClient /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -94,7 +94,7 @@ public async Task NearObject( /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/GenerateClient.NearText.cs b/src/Weaviate.Client/GenerateClient.NearText.cs index 37f28799..c3969df3 100644 --- a/src/Weaviate.Client/GenerateClient.NearText.cs +++ b/src/Weaviate.Client/GenerateClient.NearText.cs @@ -22,7 +22,7 @@ public partial class GenerateClient /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -98,7 +98,7 @@ public async Task NearText( /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -171,7 +171,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -239,7 +239,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -308,7 +308,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -366,7 +366,7 @@ await NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/GenerateClient.NearVector.cs b/src/Weaviate.Client/GenerateClient.NearVector.cs index 4a0a31de..875e2c56 100644 --- a/src/Weaviate.Client/GenerateClient.NearVector.cs +++ b/src/Weaviate.Client/GenerateClient.NearVector.cs @@ -20,6 +20,7 @@ public partial class GenerateClient /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -84,6 +85,7 @@ await _client.GrpcClient.SearchNearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -149,6 +151,7 @@ await _client.GrpcClient.SearchNearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -211,6 +214,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/QueryClient.BM25.cs b/src/Weaviate.Client/QueryClient.BM25.cs index 536b3169..ff33877f 100644 --- a/src/Weaviate.Client/QueryClient.BM25.cs +++ b/src/Weaviate.Client/QueryClient.BM25.cs @@ -20,7 +20,7 @@ public partial class QueryClient /// The offset /// The search operator /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The after /// The consistency level /// The return properties @@ -81,7 +81,7 @@ await _grpc.SearchBM25( /// The offset /// The search operator /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The after /// The consistency level /// The return properties diff --git a/src/Weaviate.Client/QueryClient.Hybrid.cs b/src/Weaviate.Client/QueryClient.Hybrid.cs index 6dc91f99..b2cb59f2 100644 --- a/src/Weaviate.Client/QueryClient.Hybrid.cs +++ b/src/Weaviate.Client/QueryClient.Hybrid.cs @@ -23,6 +23,7 @@ public partial class QueryClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -86,6 +87,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -162,6 +164,7 @@ public async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -228,6 +231,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -323,6 +327,7 @@ public static class QueryClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -395,6 +400,7 @@ public static async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/QueryClient.NearMedia.cs b/src/Weaviate.Client/QueryClient.NearMedia.cs index 0da1d2b1..95a9e00b 100644 --- a/src/Weaviate.Client/QueryClient.NearMedia.cs +++ b/src/Weaviate.Client/QueryClient.NearMedia.cs @@ -32,7 +32,7 @@ public partial class QueryClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -101,7 +101,7 @@ public async Task NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -167,7 +167,7 @@ public async Task NearMedia( /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vectors factory function for multi-vector collections. /// Properties to return in the response. /// Cross-references to return. @@ -235,7 +235,7 @@ await _grpc.SearchNearMedia( /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vectors factory function for multi-vector collections. /// Properties to return in the response. /// Cross-references to return. diff --git a/src/Weaviate.Client/QueryClient.NearObject.cs b/src/Weaviate.Client/QueryClient.NearObject.cs index b5504ccc..14f0465a 100644 --- a/src/Weaviate.Client/QueryClient.NearObject.cs +++ b/src/Weaviate.Client/QueryClient.NearObject.cs @@ -20,7 +20,7 @@ public partial class QueryClient /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The targets /// The return properties /// The return references @@ -84,7 +84,7 @@ await _grpc.SearchNearObject( /// The auto limit /// The filters /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The targets /// The return properties /// The return references diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index a0cc92ea..82404aa6 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -283,6 +283,7 @@ public static class QueryClientNearTextExtensions /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -359,6 +360,7 @@ public static async Task NearText( /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/QueryClient.NearVector.cs b/src/Weaviate.Client/QueryClient.NearVector.cs index e01fcd35..140a5bc9 100644 --- a/src/Weaviate.Client/QueryClient.NearVector.cs +++ b/src/Weaviate.Client/QueryClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class QueryClient /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -80,7 +80,7 @@ await _grpc.SearchNearVector( /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -140,7 +140,7 @@ await _grpc.SearchNearVector( /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -196,7 +196,7 @@ await NearVector( /// The limit /// The offset /// The rerank - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -251,7 +251,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -303,7 +303,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -362,7 +362,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -412,7 +412,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs index 0923b618..500fecd5 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -92,7 +92,7 @@ public async Task> BM25( /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs index 5899d332..9beb3ad7 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs @@ -24,6 +24,7 @@ public partial class TypedGenerateClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -96,6 +97,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -172,6 +174,7 @@ public async Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -247,6 +250,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -333,6 +337,7 @@ public static class TypedGenerateClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -411,6 +416,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs index 7e13024b..b9e0d624 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs @@ -32,7 +32,7 @@ public partial class TypedGenerateClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -101,7 +101,7 @@ public async Task> NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs index 1a5dbf22..7b4cc925 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -91,7 +91,7 @@ public async Task> NearObject( /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs index 0761b84b..6105788d 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs @@ -23,7 +23,7 @@ public partial class TypedGenerateClient /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -96,7 +96,7 @@ public async Task> NearText( /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -166,7 +166,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -227,7 +227,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -289,7 +289,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -347,7 +347,7 @@ public Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs index f0842216..1967d958 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// @@ -88,7 +88,7 @@ public async Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// @@ -156,7 +156,7 @@ public async Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider @@ -220,7 +220,7 @@ public Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider @@ -283,7 +283,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -343,7 +343,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -404,7 +404,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -462,7 +462,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs b/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs index 6f352ee4..be57236d 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Number of results to skip. /// BM25 search operator (AND/OR). /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Cursor for pagination. /// Consistency level for the query. /// Properties to return in the response. @@ -83,7 +83,7 @@ public async Task> BM25( /// Number of results to skip. /// BM25 search operator (AND/OR). /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Cursor for pagination. /// Consistency level for the query. /// Properties to return in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs index 06a892c7..371ec74e 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs @@ -24,6 +24,7 @@ public partial class TypedQueryClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -87,6 +88,7 @@ public Task>> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -154,6 +156,7 @@ public async Task>> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -220,6 +223,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -316,6 +320,7 @@ public static class TypedQueryClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -385,6 +390,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs index 553331a7..892d4cca 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs @@ -26,7 +26,7 @@ public partial class TypedQueryClient /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -85,7 +85,7 @@ public async Task>> NearMedia( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs index 92f51842..e2a09f21 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Automatic result limit threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vector configuration for named vectors. /// Properties to return in the response. /// Cross-references to return. @@ -82,7 +82,7 @@ public async Task>> NearObject( /// Automatic result limit threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vector configuration for named vectors. /// Properties to return in the response. /// Cross-references to return. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs index 2c324e47..f17fad80 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs @@ -23,7 +23,7 @@ public partial class TypedQueryClient /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -87,7 +87,7 @@ public partial class TypedQueryClient /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -148,7 +148,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -200,7 +200,7 @@ public async Task>> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -253,7 +253,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -302,7 +302,7 @@ public Task>> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs index 39ae168a..95ca0967 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -79,7 +79,7 @@ public async Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -138,7 +138,7 @@ public async Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -193,7 +193,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -247,7 +247,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -298,7 +298,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -350,7 +350,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -399,7 +399,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// The boost for soft-ranking results. Preview: requires Weaviate 1.38+ (older servers silently ignore it) + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. From 27ef641048ea050a67706d38f8cd8a3d63781781 Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Tue, 18 Aug 2026 15:00:18 +0200 Subject: [PATCH 9/9] docs: drop the "Preview feature" claim from the boost documentation Boost is generally available. weaviate/docs commit da77b9e8 ("Promote the Boost API note from preview to generally available") changed the shared feature note from ":::caution Preview - added in v1.38" to ":::info Added in v1.39", so every "Preview feature" claim in the C# boost docs is now false. Three places carried it: - the tag, 106 occurrences across 24 files - the on the Boost record itself - TestBoost.cs: the file summary and five RequireVersion skip messages The version floor deliberately stays 1.38, not 1.39. The docs note says "Added in v1.39" because that is when boost went GA, but the wire field and this client's support for it are genuinely 1.38+: the integration tests gate on >= 1.38.0 and the full boost surface was verified against a live 1.38.4 server. Claiming 1.39 would understate what the client supports. The silent-ignore warning is kept too - it is the fact a user most needs, and GA status does not affect it. The RequireVersion("1.38.0", ...) gates are unchanged; only the stale "(Preview)" parenthetical is dropped from the skip messages, which still explain why a test skipped on an older server. Documentation only; no code or behaviour changes. --- .../Integration/TestBoost.cs | 12 ++++++------ src/Weaviate.Client/GenerateClient.BM25.cs | 4 ++-- src/Weaviate.Client/GenerateClient.Hybrid.cs | 12 ++++++------ src/Weaviate.Client/GenerateClient.NearMedia.cs | 4 ++-- src/Weaviate.Client/GenerateClient.NearObject.cs | 4 ++-- src/Weaviate.Client/GenerateClient.NearText.cs | 12 ++++++------ src/Weaviate.Client/GenerateClient.NearVector.cs | 16 ++++++++-------- src/Weaviate.Client/Models/Boost.cs | 2 +- src/Weaviate.Client/QueryClient.BM25.cs | 4 ++-- src/Weaviate.Client/QueryClient.Hybrid.cs | 12 ++++++------ src/Weaviate.Client/QueryClient.NearMedia.cs | 8 ++++---- src/Weaviate.Client/QueryClient.NearObject.cs | 4 ++-- src/Weaviate.Client/QueryClient.NearText.cs | 12 ++++++------ src/Weaviate.Client/QueryClient.NearVector.cs | 16 ++++++++-------- .../Typed/TypedGenerateClient.BM25.cs | 4 ++-- .../Typed/TypedGenerateClient.Hybrid.cs | 12 ++++++------ .../Typed/TypedGenerateClient.NearMedia.cs | 4 ++-- .../Typed/TypedGenerateClient.NearObject.cs | 4 ++-- .../Typed/TypedGenerateClient.NearText.cs | 12 ++++++------ .../Typed/TypedGenerateClient.NearVector.cs | 16 ++++++++-------- .../Typed/TypedQueryClient.BM25.cs | 4 ++-- .../Typed/TypedQueryClient.Hybrid.cs | 12 ++++++------ .../Typed/TypedQueryClient.NearMedia.cs | 4 ++-- .../Typed/TypedQueryClient.NearObject.cs | 4 ++-- .../Typed/TypedQueryClient.NearText.cs | 12 ++++++------ .../Typed/TypedQueryClient.NearVector.cs | 16 ++++++++-------- 26 files changed, 113 insertions(+), 113 deletions(-) diff --git a/src/Weaviate.Client.Tests/Integration/TestBoost.cs b/src/Weaviate.Client.Tests/Integration/TestBoost.cs index 30dcca47..bf85e1b9 100644 --- a/src/Weaviate.Client.Tests/Integration/TestBoost.cs +++ b/src/Weaviate.Client.Tests/Integration/TestBoost.cs @@ -3,7 +3,7 @@ namespace Weaviate.Client.Tests.Integration; /// -/// Integration tests for the Boost query parameter (soft-ranking, Weaviate 1.38+ Preview). +/// Integration tests for the Boost query parameter (soft-ranking, Weaviate 1.38+). /// public partial class SearchTests { @@ -107,7 +107,7 @@ private static List Labels(WeaviateResult result) => [Fact] public async Task Test_Boost_Filter_PromotesMatchingObjects() { - RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0 (Preview)"); + RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0"); var collection = await BoostCollectionFactory(); @@ -129,7 +129,7 @@ public async Task Test_Boost_Filter_PromotesMatchingObjects() [Fact] public async Task Test_Boost_NumericProperty_RanksByValue() { - RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0 (Preview)"); + RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0"); var collection = await BoostCollectionFactory(); @@ -149,7 +149,7 @@ public async Task Test_Boost_NumericProperty_RanksByValue() [Fact] public async Task Test_Boost_TimeDecay_PrefersRecentObjects() { - RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0 (Preview)"); + RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0"); var collection = await BoostCollectionFactory(); @@ -169,7 +169,7 @@ public async Task Test_Boost_TimeDecay_PrefersRecentObjects() [Fact] public async Task Test_Boost_NumericDecay_OnNearVector_PrefersClosestToOrigin() { - RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0 (Preview)"); + RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0"); var collection = await CollectionFactory( properties: Property.FromClass(), @@ -209,7 +209,7 @@ await collection.Data.Insert( [Fact] public async Task Test_Boost_Blend_WeighsConditions() { - RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0 (Preview)"); + RequireVersion("1.38.0", message: "Boost API requires Weaviate >= 1.38.0"); var collection = await BoostCollectionFactory(); diff --git a/src/Weaviate.Client/GenerateClient.BM25.cs b/src/Weaviate.Client/GenerateClient.BM25.cs index e1b99bb4..00c1a8bc 100644 --- a/src/Weaviate.Client/GenerateClient.BM25.cs +++ b/src/Weaviate.Client/GenerateClient.BM25.cs @@ -20,7 +20,7 @@ public partial class GenerateClient /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -92,7 +92,7 @@ public async Task BM25( /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index 69f592a4..cdf0360b 100644 --- a/src/Weaviate.Client/GenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/GenerateClient.Hybrid.cs @@ -23,7 +23,7 @@ public partial class GenerateClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -96,7 +96,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -183,7 +183,7 @@ public async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -259,7 +259,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -366,7 +366,7 @@ public static class GenerateClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -444,7 +444,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/GenerateClient.NearMedia.cs b/src/Weaviate.Client/GenerateClient.NearMedia.cs index b17192cc..ea78f41b 100644 --- a/src/Weaviate.Client/GenerateClient.NearMedia.cs +++ b/src/Weaviate.Client/GenerateClient.NearMedia.cs @@ -31,7 +31,7 @@ public partial class GenerateClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -109,7 +109,7 @@ public async Task NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/GenerateClient.NearObject.cs b/src/Weaviate.Client/GenerateClient.NearObject.cs index 2dbc8279..766dcd59 100644 --- a/src/Weaviate.Client/GenerateClient.NearObject.cs +++ b/src/Weaviate.Client/GenerateClient.NearObject.cs @@ -20,7 +20,7 @@ public partial class GenerateClient /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -94,7 +94,7 @@ public async Task NearObject( /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/GenerateClient.NearText.cs b/src/Weaviate.Client/GenerateClient.NearText.cs index c3969df3..05fa8671 100644 --- a/src/Weaviate.Client/GenerateClient.NearText.cs +++ b/src/Weaviate.Client/GenerateClient.NearText.cs @@ -22,7 +22,7 @@ public partial class GenerateClient /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -98,7 +98,7 @@ public async Task NearText( /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -171,7 +171,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -239,7 +239,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -308,7 +308,7 @@ public async Task NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -366,7 +366,7 @@ await NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/GenerateClient.NearVector.cs b/src/Weaviate.Client/GenerateClient.NearVector.cs index 875e2c56..5d1fe2a0 100644 --- a/src/Weaviate.Client/GenerateClient.NearVector.cs +++ b/src/Weaviate.Client/GenerateClient.NearVector.cs @@ -20,7 +20,7 @@ public partial class GenerateClient /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -85,7 +85,7 @@ await _client.GrpcClient.SearchNearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -151,7 +151,7 @@ await _client.GrpcClient.SearchNearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -214,7 +214,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -276,7 +276,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -336,7 +336,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -397,7 +397,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -455,7 +455,7 @@ await NearVector( /// Maximum number of results to return. If not specified, the server default limit is used. /// Number of results to skip. If not specified, results start from the first object. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/Models/Boost.cs b/src/Weaviate.Client/Models/Boost.cs index 162f65a9..731a97f8 100644 --- a/src/Weaviate.Client/Models/Boost.cs +++ b/src/Weaviate.Client/Models/Boost.cs @@ -19,7 +19,7 @@ namespace Weaviate.Client.Models; /// : combine several of the above, each with its own weight. /// /// -/// Preview feature: requires Weaviate 1.38 or later. Older servers silently ignore the boost. +/// Requires Weaviate 1.38 or later. Older servers silently ignore the boost. /// public sealed record Boost { diff --git a/src/Weaviate.Client/QueryClient.BM25.cs b/src/Weaviate.Client/QueryClient.BM25.cs index ff33877f..3a48111e 100644 --- a/src/Weaviate.Client/QueryClient.BM25.cs +++ b/src/Weaviate.Client/QueryClient.BM25.cs @@ -20,7 +20,7 @@ public partial class QueryClient /// The offset /// The search operator /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The after /// The consistency level /// The return properties @@ -81,7 +81,7 @@ await _grpc.SearchBM25( /// The offset /// The search operator /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The after /// The consistency level /// The return properties diff --git a/src/Weaviate.Client/QueryClient.Hybrid.cs b/src/Weaviate.Client/QueryClient.Hybrid.cs index b2cb59f2..d590ac40 100644 --- a/src/Weaviate.Client/QueryClient.Hybrid.cs +++ b/src/Weaviate.Client/QueryClient.Hybrid.cs @@ -23,7 +23,7 @@ public partial class QueryClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -87,7 +87,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -164,7 +164,7 @@ public async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -231,7 +231,7 @@ public Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -327,7 +327,7 @@ public static class QueryClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -400,7 +400,7 @@ public static async Task Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/QueryClient.NearMedia.cs b/src/Weaviate.Client/QueryClient.NearMedia.cs index 95a9e00b..cee77027 100644 --- a/src/Weaviate.Client/QueryClient.NearMedia.cs +++ b/src/Weaviate.Client/QueryClient.NearMedia.cs @@ -32,7 +32,7 @@ public partial class QueryClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -101,7 +101,7 @@ public async Task NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -167,7 +167,7 @@ public async Task NearMedia( /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vectors factory function for multi-vector collections. /// Properties to return in the response. /// Cross-references to return. @@ -235,7 +235,7 @@ await _grpc.SearchNearMedia( /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vectors factory function for multi-vector collections. /// Properties to return in the response. /// Cross-references to return. diff --git a/src/Weaviate.Client/QueryClient.NearObject.cs b/src/Weaviate.Client/QueryClient.NearObject.cs index 14f0465a..597aa074 100644 --- a/src/Weaviate.Client/QueryClient.NearObject.cs +++ b/src/Weaviate.Client/QueryClient.NearObject.cs @@ -20,7 +20,7 @@ public partial class QueryClient /// The auto limit /// The filters /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The targets /// The return properties /// The return references @@ -84,7 +84,7 @@ await _grpc.SearchNearObject( /// The auto limit /// The filters /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The targets /// The return properties /// The return references diff --git a/src/Weaviate.Client/QueryClient.NearText.cs b/src/Weaviate.Client/QueryClient.NearText.cs index 82404aa6..c095ec67 100644 --- a/src/Weaviate.Client/QueryClient.NearText.cs +++ b/src/Weaviate.Client/QueryClient.NearText.cs @@ -20,7 +20,7 @@ public partial class QueryClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -83,7 +83,7 @@ await _grpc.SearchNearText( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -154,7 +154,7 @@ await _grpc.SearchNearText( /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -215,7 +215,7 @@ public async Task NearText( /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -283,7 +283,7 @@ public static class QueryClientNearTextExtensions /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -360,7 +360,7 @@ public static async Task NearText( /// Diversity selection (MMR) to apply to the results. If not specified, no diversification is applied. /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/QueryClient.NearVector.cs b/src/Weaviate.Client/QueryClient.NearVector.cs index 140a5bc9..3a149103 100644 --- a/src/Weaviate.Client/QueryClient.NearVector.cs +++ b/src/Weaviate.Client/QueryClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class QueryClient /// The limit /// The offset /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -80,7 +80,7 @@ await _grpc.SearchNearVector( /// The limit /// The offset /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -140,7 +140,7 @@ await _grpc.SearchNearVector( /// The limit /// The offset /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -196,7 +196,7 @@ await NearVector( /// The limit /// The offset /// The rerank - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// The return properties /// The return references /// The return metadata @@ -251,7 +251,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -303,7 +303,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -362,7 +362,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -412,7 +412,7 @@ await NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs index 500fecd5..617f8d4c 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.BM25.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -92,7 +92,7 @@ public async Task> BM25( /// Offset for pagination /// BM25 search operator (AND/OR) /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs index 9beb3ad7..dd761b04 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.Hybrid.cs @@ -24,7 +24,7 @@ public partial class TypedGenerateClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -97,7 +97,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -174,7 +174,7 @@ public async Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -250,7 +250,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -337,7 +337,7 @@ public static class TypedGenerateClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. @@ -416,7 +416,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Prompt run separately for each returned object. If not specified, no per-object generation is performed. /// Prompt run once over the whole result set. If not specified, no grouped generation is performed. /// Generative provider applied to prompts that do not carry one. Throws if a prompt already has a provider. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs index b9e0d624..8863ed31 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearMedia.cs @@ -32,7 +32,7 @@ public partial class TypedGenerateClient /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -101,7 +101,7 @@ public async Task> NearMedia( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs index 7b4cc925..eb9d80e4 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearObject.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -91,7 +91,7 @@ public async Task> NearObject( /// Auto-limit threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs index 6105788d..1e962ede 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearText.cs @@ -23,7 +23,7 @@ public partial class TypedGenerateClient /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -96,7 +96,7 @@ public async Task> NearText( /// Auto-cut threshold /// Filters to apply /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider to enrich prompts that don't have a provider set. If the prompt already has a provider, it will not be overridden. @@ -166,7 +166,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -227,7 +227,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -289,7 +289,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -347,7 +347,7 @@ public Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs b/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs index 1967d958..c626492c 100644 --- a/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs +++ b/src/Weaviate.Client/Typed/TypedGenerateClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class TypedGenerateClient /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// @@ -88,7 +88,7 @@ public async Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// @@ -156,7 +156,7 @@ public async Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider @@ -220,7 +220,7 @@ public Task> NearVector( /// Maximum number of results /// Offset for pagination /// Rerank configuration - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generation /// Grouped prompt for generation /// Optional generative provider @@ -283,7 +283,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -343,7 +343,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -404,7 +404,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. @@ -462,7 +462,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Single prompt for generative AI. /// Grouped task for generative AI. /// Generative AI provider configuration. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs b/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs index be57236d..87553397 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.BM25.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Number of results to skip. /// BM25 search operator (AND/OR). /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Cursor for pagination. /// Consistency level for the query. /// Properties to return in the response. @@ -83,7 +83,7 @@ public async Task> BM25( /// Number of results to skip. /// BM25 search operator (AND/OR). /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Cursor for pagination. /// Consistency level for the query. /// Properties to return in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs index 371ec74e..852c34e3 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.Hybrid.cs @@ -24,7 +24,7 @@ public partial class TypedQueryClient /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -88,7 +88,7 @@ public Task>> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -156,7 +156,7 @@ public async Task>> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -223,7 +223,7 @@ public Task> Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -320,7 +320,7 @@ public static class TypedQueryClientHybridExtensions /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. @@ -390,7 +390,7 @@ await client.Hybrid( /// Automatic result cutoff (autocut): results stop after this many jumps in score or distance. If not specified, no cutoff is applied. /// Filters to apply to the search. /// Re-ranking configuration. Requires a reranker model integration on the collection. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. If not specified, all non-blob properties are returned. /// Cross-references to return. If not specified, no references are returned. /// Metadata to include in the response. If not specified, no metadata is returned. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs index 892d4cca..e92ce998 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearMedia.cs @@ -26,7 +26,7 @@ public partial class TypedQueryClient /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -85,7 +85,7 @@ public async Task>> NearMedia( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs index e2a09f21..561e77f3 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearObject.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Automatic result limit threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vector configuration for named vectors. /// Properties to return in the response. /// Cross-references to return. @@ -82,7 +82,7 @@ public async Task>> NearObject( /// Automatic result limit threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Target vector configuration for named vectors. /// Properties to return in the response. /// Cross-references to return. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs index f17fad80..27797ca9 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearText.cs @@ -23,7 +23,7 @@ public partial class TypedQueryClient /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -87,7 +87,7 @@ public partial class TypedQueryClient /// Automatic result cutoff threshold. /// Filters to apply to the search. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -148,7 +148,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -200,7 +200,7 @@ public async Task>> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -253,7 +253,7 @@ public async Task> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -302,7 +302,7 @@ public Task>> NearText( /// Diversity selection to apply to the results. /// Automatic result cutoff threshold. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. diff --git a/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs b/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs index 95ca0967..4a806720 100644 --- a/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs +++ b/src/Weaviate.Client/Typed/TypedQueryClient.NearVector.cs @@ -21,7 +21,7 @@ public partial class TypedQueryClient /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -79,7 +79,7 @@ public async Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -138,7 +138,7 @@ public async Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -193,7 +193,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -247,7 +247,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -298,7 +298,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -350,7 +350,7 @@ public Task> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response. @@ -399,7 +399,7 @@ public Task>> NearVector( /// Maximum number of results to return. /// Number of results to skip. /// Re-ranking configuration. - /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Preview feature: requires Weaviate 1.38 or later; older servers silently ignore it. + /// Soft-ranking to apply to the results: promotes or demotes objects in the pool of candidates the search fetches, re-scoring them rather than excluding them the way a filter does. If not specified, no boost is applied. Requires Weaviate 1.38 or later; older servers silently ignore it. /// Properties to return in the response. /// Cross-references to return. /// Metadata to include in the response.