diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index 00bf3c3a..0bad2d1b 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()) diff --git a/src/Weaviate.Client/GenerateClient.Hybrid.cs b/src/Weaviate.Client/GenerateClient.Hybrid.cs index 100ff4bd..b4feba6d 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 74bac5ab..5639e0ab 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 ac7be75a..36406607 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 b3ff03b6..f96c73da 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 80971328..54e8e405 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 0a23983e..ca7349f4 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,