From 5363553156458a8162041802f24748311899ca45 Mon Sep 17 00:00:00 2001 From: Ivan Despot <66276597+g-despot@users.noreply.github.com> Date: Wed, 9 Sep 2026 12:36:19 +0200 Subject: [PATCH] feat: add the generative-meta module (Weaviate 1.39.3) --- .github/workflows/main.yaml | 2 +- ci/docker-compose.yml | 2 +- .../Integration/TestCollections.cs | 44 ++++++++++ .../Unit/TestCollection.cs | 64 ++++++++++++++ .../Unit/TestGenerativeShortcuts.cs | 47 ++++++++++ .../Configure/GenerativeConfig.cs | 34 ++++++++ .../Configure/GenerativeProvider.cs | 34 ++++++++ .../Models/Generative/Providers.cs | 87 +++++++++++++++++++ .../Models/GenerativeConfig.cs | 63 ++++++++++++++ .../Models/Serialization.GenerativeConfig.cs | 5 ++ src/Weaviate.Client/PublicAPI.Unshipped.txt | 68 +++++++++++++++ src/Weaviate.Client/gRPC/Search.Builders.cs | 15 ++++ .../gRPC/proto/v1/generative.proto | 33 +++++++ 13 files changed, 496 insertions(+), 2 deletions(-) diff --git a/.github/workflows/main.yaml b/.github/workflows/main.yaml index 97e4c11d..3c12517a 100644 --- a/.github/workflows/main.yaml +++ b/.github/workflows/main.yaml @@ -142,7 +142,7 @@ jobs: strategy: fail-fast: false matrix: - version: ["1.32.27", "1.33.18", "1.34.20", "1.35.23", "1.36.23", "1.37.16", "1.38.9", "1.39.0"] + version: ["1.32.27", "1.33.18", "1.34.20", "1.35.23", "1.36.23", "1.37.16", "1.38.9", "1.39.3"] uses: ./.github/workflows/test-on-weaviate-version.yml secrets: inherit with: diff --git a/ci/docker-compose.yml b/ci/docker-compose.yml index 8985a259..4c23333f 100644 --- a/ci/docker-compose.yml +++ b/ci/docker-compose.yml @@ -22,7 +22,7 @@ services: QUERY_DEFAULTS_LIMIT: 25 AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true' PERSISTENCE_DATA_PATH: '/var/lib/weaviate' - ENABLE_MODULES: text2vec-transformers,text2vec-cohere,backup-filesystem,generative-dummy,generative-anyscale,reranker-dummy,reranker-cohere,text2vec-ollama,generative-ollama,multi2vec-google,generative-deepseek,generative-digitalocean + ENABLE_MODULES: text2vec-transformers,text2vec-cohere,backup-filesystem,generative-dummy,generative-anyscale,reranker-dummy,reranker-cohere,text2vec-ollama,generative-ollama,multi2vec-google,generative-deepseek,generative-digitalocean,generative-meta BACKUP_FILESYSTEM_PATH: "/tmp/backups" EXPORT_ENABLED: 'true' EXPORT_DEFAULT_PATH: "/tmp/exports" diff --git a/src/Weaviate.Client.Tests/Integration/TestCollections.cs b/src/Weaviate.Client.Tests/Integration/TestCollections.cs index 3c38f3a8..79838570 100644 --- a/src/Weaviate.Client.Tests/Integration/TestCollections.cs +++ b/src/Weaviate.Client.Tests/Integration/TestCollections.cs @@ -289,6 +289,50 @@ public async Task Collection_Creates_And_Retrieves_GenerativeDigitalOcean_Config Assert.Equal(["STOP"], digitalOcean.Stop); } + /// + /// Tests that a generative-meta collection round-trips through a real server. + /// + /// + /// Fractional floats are dropped by the server's config parser — integral values only. + /// + [Fact] + public async Task Collection_Creates_And_Retrieves_GenerativeMeta_Config() + { + RequireModule("generative-meta"); + + // Arrange + var collectionClient = await CollectionFactory( + properties: [Property.Text("Name")], + generativeConfig: Configure.Generative.Meta( + model: "muse-spark-1.2", + temperature: 1, + maxTokens: 100, + frequencyPenalty: 0, + presencePenalty: 0, + topP: 1, + baseURL: "https://api.meta.ai", + reasoningEffort: "xhigh" + ) + ); + + // Act + var collection = await _weaviate + .Collections.Use(collectionClient.Name) + .Config.Get(TestContext.Current.CancellationToken); + + // Assert + Assert.NotNull(collection); + var meta = Assert.IsType(collection.GenerativeConfig); + Assert.Equal("muse-spark-1.2", meta.Model); + Assert.Equal(1, meta.Temperature); + Assert.Equal(100, meta.MaxTokens); + Assert.Equal(0, meta.FrequencyPenalty); + Assert.Equal(0, meta.PresencePenalty); + Assert.Equal(1, meta.TopP); + Assert.Equal("https://api.meta.ai", meta.BaseURL); + Assert.Equal("xhigh", meta.ReasoningEffort); + } + /// /// Tests that test collections export /// diff --git a/src/Weaviate.Client.Tests/Unit/TestCollection.cs b/src/Weaviate.Client.Tests/Unit/TestCollection.cs index 08771d46..69f49b26 100644 --- a/src/Weaviate.Client.Tests/Unit/TestCollection.cs +++ b/src/Weaviate.Client.Tests/Unit/TestCollection.cs @@ -529,6 +529,70 @@ public void Collection_GenerativeDigitalOcean_Serializes_And_RoundTrips() Assert.Equal(["STOP"], typed.Stop); } + /// + /// Pins the exact wire keys — a wrong key or casing is silently ignored by the server. + /// + [Fact] + public void Collection_GenerativeMeta_Serializes_And_RoundTrips() + { + // Arrange + var full = Assert.IsType( + Configure.Generative.Meta( + model: "muse-spark-1.2", + temperature: 0.5, + maxTokens: 100, + frequencyPenalty: 0.1, + presencePenalty: 0.2, + topP: 0.9, + baseURL: "https://api.meta.ai", + reasoningEffort: "xhigh" + ) + ); + var empty = Assert.IsType(Configure.Generative.Meta()); + + // Act + var jsonFull = JsonSerializer.Serialize( + full, + Rest.WeaviateRestClient.RestJsonSerializerOptions + ); + var jsonEmpty = JsonSerializer.Serialize( + empty, + Rest.WeaviateRestClient.RestJsonSerializerOptions + ); + + // Assert + Assert.Equal("generative-meta", full.Type); + Assert.Contains("\"model\":\"muse-spark-1.2\"", jsonFull); + Assert.Contains("\"temperature\":0.5", jsonFull); + Assert.Contains("\"maxTokens\":100", jsonFull); + Assert.Contains("\"frequencyPenalty\":0.1", jsonFull); + Assert.Contains("\"presencePenalty\":0.2", jsonFull); + Assert.Contains("\"topP\":0.9", jsonFull); + Assert.Contains("\"baseURL\":\"https://api.meta.ai\"", jsonFull); + Assert.Contains("\"reasoningEffort\":\"xhigh\"", jsonFull); + Assert.Contains("\"type\":\"generative-meta\"", jsonFull); + + // Nothing set means nothing else sent, so the server keeps its own defaults. + Assert.Equal("{\"type\":\"generative-meta\"}", jsonEmpty); + + var roundTripped = GenerativeConfigSerialization.Factory( + GenerativeConfig.Meta.TypeValue, + JsonSerializer.Deserialize( + jsonFull, + Rest.WeaviateRestClient.RestJsonSerializerOptions + ) + ); + var typed = Assert.IsType(roundTripped); + Assert.Equal("muse-spark-1.2", typed.Model); + Assert.Equal(0.5, typed.Temperature); + Assert.Equal(100, typed.MaxTokens); + Assert.Equal(0.1, typed.FrequencyPenalty); + Assert.Equal(0.2, typed.PresencePenalty); + Assert.Equal(0.9, typed.TopP); + Assert.Equal("https://api.meta.ai", typed.BaseURL); + Assert.Equal("xhigh", typed.ReasoningEffort); + } + /// /// Tests that collection rerank deserializes into i reranker config /// diff --git a/src/Weaviate.Client.Tests/Unit/TestGenerativeShortcuts.cs b/src/Weaviate.Client.Tests/Unit/TestGenerativeShortcuts.cs index e512a7ff..59df1c21 100644 --- a/src/Weaviate.Client.Tests/Unit/TestGenerativeShortcuts.cs +++ b/src/Weaviate.Client.Tests/Unit/TestGenerativeShortcuts.cs @@ -437,6 +437,53 @@ await client Assert.False(providerQuery.Digitalocean.HasPresencePenalty); } + /// + /// Tests that the Meta provider maps onto the gRPC message; unset optionals stay unset. + /// + [Fact] + public async Task GenerateClient_FetchObjects_WithMetaProvider_MapsSetFieldsAndOmitsUnset() + { + // Arrange + var provider = new Providers.Meta + { + BaseUrl = "https://api.meta.ai", + Model = "muse-spark-1.2", + Temperature = 0.5, + MaxTokens = 100, + FrequencyPenalty = 0.1, + TopP = 0.9, + ReasoningEffort = Providers.Meta.ReasoningEffortLevel.XHigh, + }; + var (client, getCapturedRequest) = CreateClientWithRequestCapture(); + + // Act + await client + .Collections.Use("TestCollection") + .Generate.FetchObjects( + limit: 10, + singlePrompt: "Summarize this", + provider: provider, + cancellationToken: TestContext.Current.CancellationToken + ); + + // Assert + var capturedRequest = getCapturedRequest(); + Assert.NotNull(capturedRequest); + var providerQuery = capturedRequest!.Generative!.Single!.Queries[0]; + Assert.NotNull(providerQuery.Meta); + Assert.Equal("https://api.meta.ai", providerQuery.Meta.BaseUrl); + Assert.Equal("muse-spark-1.2", providerQuery.Meta.Model); + Assert.Equal(0.5, providerQuery.Meta.Temperature); + Assert.Equal(100, providerQuery.Meta.MaxTokens); + Assert.Equal(0.1, providerQuery.Meta.FrequencyPenalty); + Assert.Equal(0.9, providerQuery.Meta.TopP); + Assert.Equal( + GenerativeMeta.Types.ReasoningEffort.Xhigh, + providerQuery.Meta.ReasoningEffort + ); + Assert.False(providerQuery.Meta.HasPresencePenalty); + } + #endregion #region Helper Methods diff --git a/src/Weaviate.Client/Configure/GenerativeConfig.cs b/src/Weaviate.Client/Configure/GenerativeConfig.cs index b5318025..753d3c6e 100644 --- a/src/Weaviate.Client/Configure/GenerativeConfig.cs +++ b/src/Weaviate.Client/Configure/GenerativeConfig.cs @@ -291,6 +291,40 @@ public IGenerativeConfig FriendliAI( Temperature = temperature, }; + /// + /// Create a generative configuration for Meta. + /// + /// The model to use. + /// The temperature. + /// The maximum number of tokens to generate. + /// The frequency penalty. + /// The presence penalty. + /// The top P. + /// The base URL. + /// The reasoning effort. + /// A instance. + public IGenerativeConfig Meta( + string? model = null, + double? temperature = null, + int? maxTokens = null, + double? frequencyPenalty = null, + double? presencePenalty = null, + double? topP = null, + string? baseURL = null, + string? reasoningEffort = null + ) => + new GenerativeConfig.Meta + { + Model = model, + Temperature = temperature, + MaxTokens = maxTokens, + FrequencyPenalty = frequencyPenalty, + PresencePenalty = presencePenalty, + TopP = topP, + BaseURL = baseURL, + ReasoningEffort = reasoningEffort, + }; + /// /// Create a generative configuration for Mistral. /// diff --git a/src/Weaviate.Client/Configure/GenerativeProvider.cs b/src/Weaviate.Client/Configure/GenerativeProvider.cs index bbfbba3f..df62b5a2 100644 --- a/src/Weaviate.Client/Configure/GenerativeProvider.cs +++ b/src/Weaviate.Client/Configure/GenerativeProvider.cs @@ -522,6 +522,40 @@ public Providers.GoogleVertex GoogleVertex( ImageProperties = imageProperties, }; + /// + /// Creates a Meta runtime provider configuration. + /// + /// The base url + /// The model + /// The temperature + /// The max tokens + /// The frequency penalty + /// The presence penalty + /// The top + /// The reasoning effort + /// The providers meta + public Providers.Meta Meta( + string? baseUrl = null, + string? model = null, + double? temperature = null, + long? maxTokens = null, + double? frequencyPenalty = null, + double? presencePenalty = null, + double? topP = null, + Providers.Meta.ReasoningEffortLevel? reasoningEffort = null + ) => + new() + { + BaseUrl = baseUrl, + Model = model, + Temperature = temperature, + MaxTokens = maxTokens, + FrequencyPenalty = frequencyPenalty, + PresencePenalty = presencePenalty, + TopP = topP, + ReasoningEffort = reasoningEffort, + }; + /// /// Mistrals the base url /// diff --git a/src/Weaviate.Client/Models/Generative/Providers.cs b/src/Weaviate.Client/Models/Generative/Providers.cs index a5df9270..a30545e4 100644 --- a/src/Weaviate.Client/Models/Generative/Providers.cs +++ b/src/Weaviate.Client/Models/Generative/Providers.cs @@ -914,6 +914,93 @@ public record DigitalOcean() : GenerativeProvider("digitalocean") public List? Stop { get; set; } } + /// + /// Configuration for Meta generative AI provider. + /// + public record Meta() : GenerativeProvider("meta") + { + /// + /// Specifies the reasoning effort level for reasoning models. + /// + public enum ReasoningEffortLevel + { + /// + /// Unspecified reasoning effort level. + /// + Unspecified = 0, + + /// + /// No reasoning effort. + /// + None = 1, + + /// + /// Minimal reasoning effort. + /// + Minimal = 2, + + /// + /// Low reasoning effort. + /// + Low = 3, + + /// + /// Medium reasoning effort. + /// + Medium = 4, + + /// + /// High reasoning effort. + /// + High = 5, + + /// + /// Extra-high reasoning effort. + /// + XHigh = 6, + } + + /// + /// Gets or sets the base URL for the Meta API endpoint. + /// + public string? BaseUrl { get; set; } + + /// + /// Gets or sets the model identifier to use. + /// + public string? Model { get; set; } + + /// + /// Gets or sets the temperature for controlling randomness in generation. + /// + public double? Temperature { get; set; } + + /// + /// Gets or sets the maximum number of tokens to generate. + /// + public long? MaxTokens { get; set; } + + /// + /// Gets or sets the frequency penalty to reduce repetition. + /// + public double? FrequencyPenalty { get; set; } + + /// + /// Gets or sets the presence penalty to encourage topic diversity. + /// + public double? PresencePenalty { get; set; } + + /// + /// Gets or sets the top-p (nucleus) sampling parameter. + /// + public double? TopP { get; set; } + + /// + /// Gets or sets the reasoning effort level for reasoning models. + /// + public ReasoningEffortLevel? ReasoningEffort { get; set; } + } + /// /// Configuration for FriendliAI generative AI provider. /// diff --git a/src/Weaviate.Client/Models/GenerativeConfig.cs b/src/Weaviate.Client/Models/GenerativeConfig.cs index 996bd481..5b9c5938 100644 --- a/src/Weaviate.Client/Models/GenerativeConfig.cs +++ b/src/Weaviate.Client/Models/GenerativeConfig.cs @@ -544,6 +544,69 @@ internal FriendliAI() { } public double? Temperature { get; set; } } + /// + /// Configuration for Meta generative AI provider. + /// + public record Meta : IGenerativeConfig + { + /// + /// Initializes a new instance of the class. + /// + [JsonConstructor] + internal Meta() { } + + /// + /// The type value for Meta configuration. + /// + public const string TypeValue = "generative-meta"; + + /// + /// Gets the type identifier for the configuration. + /// + public string Type => TypeValue; + + /// + /// Gets or sets the model identifier to use. + /// + public string? Model { get; set; } + + /// + /// Gets or sets the temperature for controlling randomness in generation. + /// + public double? Temperature { get; set; } + + /// + /// Gets or sets the maximum number of tokens to generate. + /// + public int? MaxTokens { get; set; } + + /// + /// Gets or sets the frequency penalty to reduce repetition. + /// + public double? FrequencyPenalty { get; set; } + + /// + /// Gets or sets the presence penalty to encourage topic diversity. + /// + public double? PresencePenalty { get; set; } + + /// + /// Gets or sets the top-p (nucleus) sampling parameter. + /// + public double? TopP { get; set; } + + /// + /// Gets or sets the base URL for the Meta API endpoint. + /// + public string? BaseURL { get; set; } + + /// + /// Gets or sets the reasoning effort level for reasoning models. + /// One of "none", "minimal", "low", "medium", "high" or "xhigh". + /// + public string? ReasoningEffort { get; set; } + } + /// /// Configuration for Mistral generative AI provider. /// diff --git a/src/Weaviate.Client/Models/Serialization.GenerativeConfig.cs b/src/Weaviate.Client/Models/Serialization.GenerativeConfig.cs index b21f6905..3eb83380 100644 --- a/src/Weaviate.Client/Models/Serialization.GenerativeConfig.cs +++ b/src/Weaviate.Client/Models/Serialization.GenerativeConfig.cs @@ -63,6 +63,11 @@ internal static class GenerativeConfigSerialization text, Rest.WeaviateRestClient.RestJsonSerializerOptions ), + GenerativeConfig.Meta.TypeValue => + JsonSerializer.Deserialize( + text, + Rest.WeaviateRestClient.RestJsonSerializerOptions + ), GenerativeConfig.Mistral.TypeValue => JsonSerializer.Deserialize( text, diff --git a/src/Weaviate.Client/PublicAPI.Unshipped.txt b/src/Weaviate.Client/PublicAPI.Unshipped.txt index 0503acf7..c1daa908 100644 --- a/src/Weaviate.Client/PublicAPI.Unshipped.txt +++ b/src/Weaviate.Client/PublicAPI.Unshipped.txt @@ -59,3 +59,71 @@ Weaviate.Client.Models.GenerativeConfig.DigitalOcean.Temperature.set -> void Weaviate.Client.Models.GenerativeConfig.DigitalOcean.TopP.get -> double? Weaviate.Client.Models.GenerativeConfig.DigitalOcean.TopP.set -> void Weaviate.Client.Models.GenerativeConfig.DigitalOcean.Type.get -> string! +const Weaviate.Client.Models.GenerativeConfig.Meta.TypeValue = "generative-meta" -> string! +override sealed Weaviate.Client.Models.Generative.Providers.Meta.Equals(Weaviate.Client.Models.GenerativeProvider? other) -> bool +override Weaviate.Client.Models.Generative.Providers.Meta.$() -> Weaviate.Client.Models.Generative.Providers.Meta! +override Weaviate.Client.Models.Generative.Providers.Meta.EqualityContract.get -> System.Type! +override Weaviate.Client.Models.Generative.Providers.Meta.Equals(object? obj) -> bool +override Weaviate.Client.Models.Generative.Providers.Meta.GetHashCode() -> int +override Weaviate.Client.Models.Generative.Providers.Meta.PrintMembers(System.Text.StringBuilder! builder) -> bool +override Weaviate.Client.Models.Generative.Providers.Meta.ToString() -> string! +override Weaviate.Client.Models.GenerativeConfig.Meta.Equals(object? obj) -> bool +override Weaviate.Client.Models.GenerativeConfig.Meta.GetHashCode() -> int +override Weaviate.Client.Models.GenerativeConfig.Meta.ToString() -> string! +static Weaviate.Client.Models.Generative.Providers.Meta.operator !=(Weaviate.Client.Models.Generative.Providers.Meta? left, Weaviate.Client.Models.Generative.Providers.Meta? right) -> bool +static Weaviate.Client.Models.Generative.Providers.Meta.operator ==(Weaviate.Client.Models.Generative.Providers.Meta? left, Weaviate.Client.Models.Generative.Providers.Meta? right) -> bool +static Weaviate.Client.Models.GenerativeConfig.Meta.operator !=(Weaviate.Client.Models.GenerativeConfig.Meta? left, Weaviate.Client.Models.GenerativeConfig.Meta? right) -> bool +static Weaviate.Client.Models.GenerativeConfig.Meta.operator ==(Weaviate.Client.Models.GenerativeConfig.Meta? left, Weaviate.Client.Models.GenerativeConfig.Meta? right) -> bool +virtual Weaviate.Client.Models.Generative.Providers.Meta.Equals(Weaviate.Client.Models.Generative.Providers.Meta? other) -> bool +virtual Weaviate.Client.Models.GenerativeConfig.Meta.$() -> Weaviate.Client.Models.GenerativeConfig.Meta! +virtual Weaviate.Client.Models.GenerativeConfig.Meta.EqualityContract.get -> System.Type! +virtual Weaviate.Client.Models.GenerativeConfig.Meta.Equals(Weaviate.Client.Models.GenerativeConfig.Meta? other) -> bool +virtual Weaviate.Client.Models.GenerativeConfig.Meta.PrintMembers(System.Text.StringBuilder! builder) -> bool +Weaviate.Client.GenerativeConfigFactory.Meta(string? model = null, double? temperature = null, int? maxTokens = null, double? frequencyPenalty = null, double? presencePenalty = null, double? topP = null, string? baseURL = null, string? reasoningEffort = null) -> Weaviate.Client.Models.IGenerativeConfig! +Weaviate.Client.GenerativeProviderFactory.Meta(string? baseUrl = null, string? model = null, double? temperature = null, long? maxTokens = null, double? frequencyPenalty = null, double? presencePenalty = null, double? topP = null, Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel? reasoningEffort = null) -> Weaviate.Client.Models.Generative.Providers.Meta! +Weaviate.Client.Models.Generative.Providers.Meta +Weaviate.Client.Models.Generative.Providers.Meta.BaseUrl.get -> string? +Weaviate.Client.Models.Generative.Providers.Meta.BaseUrl.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.FrequencyPenalty.get -> double? +Weaviate.Client.Models.Generative.Providers.Meta.FrequencyPenalty.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.MaxTokens.get -> long? +Weaviate.Client.Models.Generative.Providers.Meta.MaxTokens.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.Meta() -> void +Weaviate.Client.Models.Generative.Providers.Meta.Meta(Weaviate.Client.Models.Generative.Providers.Meta! original) -> void +Weaviate.Client.Models.Generative.Providers.Meta.Model.get -> string? +Weaviate.Client.Models.Generative.Providers.Meta.Model.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.PresencePenalty.get -> double? +Weaviate.Client.Models.Generative.Providers.Meta.PresencePenalty.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffort.get -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel? +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffort.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.High = 5 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.Low = 3 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.Medium = 4 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.Minimal = 2 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.None = 1 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.Unspecified = 0 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel.XHigh = 6 -> Weaviate.Client.Models.Generative.Providers.Meta.ReasoningEffortLevel +Weaviate.Client.Models.Generative.Providers.Meta.Temperature.get -> double? +Weaviate.Client.Models.Generative.Providers.Meta.Temperature.set -> void +Weaviate.Client.Models.Generative.Providers.Meta.TopP.get -> double? +Weaviate.Client.Models.Generative.Providers.Meta.TopP.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta +Weaviate.Client.Models.GenerativeConfig.Meta.BaseURL.get -> string? +Weaviate.Client.Models.GenerativeConfig.Meta.BaseURL.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.FrequencyPenalty.get -> double? +Weaviate.Client.Models.GenerativeConfig.Meta.FrequencyPenalty.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.MaxTokens.get -> int? +Weaviate.Client.Models.GenerativeConfig.Meta.MaxTokens.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.Meta(Weaviate.Client.Models.GenerativeConfig.Meta! original) -> void +Weaviate.Client.Models.GenerativeConfig.Meta.Model.get -> string? +Weaviate.Client.Models.GenerativeConfig.Meta.Model.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.PresencePenalty.get -> double? +Weaviate.Client.Models.GenerativeConfig.Meta.PresencePenalty.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.ReasoningEffort.get -> string? +Weaviate.Client.Models.GenerativeConfig.Meta.ReasoningEffort.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.Temperature.get -> double? +Weaviate.Client.Models.GenerativeConfig.Meta.Temperature.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.TopP.get -> double? +Weaviate.Client.Models.GenerativeConfig.Meta.TopP.set -> void +Weaviate.Client.Models.GenerativeConfig.Meta.Type.get -> string! diff --git a/src/Weaviate.Client/gRPC/Search.Builders.cs b/src/Weaviate.Client/gRPC/Search.Builders.cs index 3f96cd43..a1041e94 100644 --- a/src/Weaviate.Client/gRPC/Search.Builders.cs +++ b/src/Weaviate.Client/gRPC/Search.Builders.cs @@ -567,6 +567,21 @@ private static V1.GenerativeProvider GetGenerativeProvider(GenerativeProvider pr SetIfNotNull(v => result.Digitalocean.FrequencyPenalty = v, a.FrequencyPenalty); SetIfNotNull(v => result.Digitalocean.PresencePenalty = v, a.PresencePenalty); break; + case Models.Generative.Providers.Meta a: + result.Meta = new V1.GenerativeMeta + { + BaseUrl = a.BaseUrl ?? string.Empty, + Model = a.Model ?? string.Empty, + ReasoningEffort = a.ReasoningEffort.HasValue + ? (V1.GenerativeMeta.Types.ReasoningEffort)a.ReasoningEffort.Value + : V1.GenerativeMeta.Types.ReasoningEffort.Unspecified, + }; + SetIfNotNull(v => result.Meta.Temperature = v, a.Temperature); + SetIfNotNull(v => result.Meta.TopP = v, a.TopP); + SetIfNotNull(v => result.Meta.MaxTokens = v, a.MaxTokens); + SetIfNotNull(v => result.Meta.FrequencyPenalty = v, a.FrequencyPenalty); + SetIfNotNull(v => result.Meta.PresencePenalty = v, a.PresencePenalty); + break; case Models.Generative.Providers.FriendliAI a: result.Friendliai = new V1.GenerativeFriendliAI { diff --git a/src/Weaviate.Client/gRPC/proto/v1/generative.proto b/src/Weaviate.Client/gRPC/proto/v1/generative.proto index e1bb8a87..f742ea64 100644 --- a/src/Weaviate.Client/gRPC/proto/v1/generative.proto +++ b/src/Weaviate.Client/gRPC/proto/v1/generative.proto @@ -51,6 +51,7 @@ message GenerativeProvider { GenerativeContextualAI contextualai = 15; GenerativeDeepseek deepseek = 16; GenerativeDigitalOcean digitalocean = 17; + GenerativeMeta meta = 18; } } @@ -243,6 +244,28 @@ message GenerativeDigitalOcean{ optional TextArray stop = 8; } +message GenerativeMeta{ + enum ReasoningEffort { + REASONING_EFFORT_UNSPECIFIED = 0; + REASONING_EFFORT_NONE = 1; + REASONING_EFFORT_MINIMAL = 2; + REASONING_EFFORT_LOW = 3; + REASONING_EFFORT_MEDIUM = 4; + REASONING_EFFORT_HIGH = 5; + REASONING_EFFORT_XHIGH = 6; + } + optional string base_url = 1; + optional string model = 2; + optional double temperature = 3; + optional double top_p = 4; + optional int64 max_tokens = 5; + optional double frequency_penalty = 6; + optional double presence_penalty = 7; + optional ReasoningEffort reasoning_effort = 8; + optional TextArray images = 9; + optional TextArray image_properties = 10; +} + message GenerativeAnthropicMetadata { message Usage { int64 input_tokens = 1; @@ -378,6 +401,15 @@ message GenerativeDigitalOceanMetadata { optional Usage usage = 1; } +message GenerativeMetaMetadata { + message Usage { + optional int64 prompt_tokens = 1; + optional int64 completion_tokens = 2; + optional int64 total_tokens = 3; + } + optional Usage usage = 1; +} + message GenerativeMetadata { oneof kind { GenerativeAnthropicMetadata anthropic = 1; @@ -395,6 +427,7 @@ message GenerativeMetadata { GenerativeXAIMetadata xai = 13; GenerativeDeepseekMetadata deepseek = 14; GenerativeDigitalOceanMetadata digitalocean = 15; + GenerativeMetaMetadata meta = 16; } }