Merge pull request #797 from nminaya/gemini-api-implementation

Gemini API implementation

Author: nminaya

GrammarNazi.App/Startup.cs

@@ -5,6 +5,7 @@
 using GrammarNazi.Core.Extensions;
 using GrammarNazi.Core.Repositories;
 using GrammarNazi.Core.Services;
+using GrammarNazi.Core.Services.GrammarServices;
 using GrammarNazi.Core.Utilities;
 using GrammarNazi.Domain.Clients;
 using GrammarNazi.Domain.Entities.Configs;
@@ -60,6 +61,7 @@ private void ConfigureDependencies(IServiceCollection services)
         services.Configure<TwitterBotSettings>(Configuration.GetSection("AppSettings:TwitterBotSettings"));
         services.Configure<GithubSettings>(Configuration.GetSection("AppSettings:GithubSettings"));
         services.Configure<DiscordSettings>(d => d.Token = Environment.GetEnvironmentVariable("DISCORD_API_KEY"));
+        services.Configure<GeminiApiSettings>(d => d.ApiKey = Environment.GetEnvironmentVariable("GEMINI_API_KEY"));
         services.Configure<MeaningCloudSettings>(m =>
         {
             m.MeaningCloudLanguageHostUrl = Configuration.GetSection("AppSettings:MeaningCloudSettings:MeaningCloudLanguageHostUrl").Value;
@@ -81,6 +83,7 @@ private void ConfigureDependencies(IServiceCollection services)
         services.AddTransient<IYandexSpellerApiClient, YandexSpellerApiClient>();
         services.AddTransient<IDatamuseApiClient, DatamuseApiClient>();
         services.AddTransient<ISentimApiClient, SentimApiClient>();
+        services.AddTransient<IGeminiApiClient, GeminiApiClient>();
         services.AddTransient<IChatConfigurationService, ChatConfigurationService>();
         services.AddTransient<IScheduledTweetService, ScheduledTweetService>();
         services.AddTransient<ITwitterMentionLogService, TwitterMentionLogService>();
@@ -89,6 +92,7 @@ private void ConfigureDependencies(IServiceCollection services)
         services.AddTransient<IGrammarService, InternalFileGrammarService>();
         services.AddTransient<IGrammarService, YandexSpellerApiService>();
         services.AddTransient<IGrammarService, DatamuseApiService>();
+        services.AddTransient<IGrammarService, GeminiApiService>();
         services.AddTransient<ITwitterLogService, TwitterLogService>();
         services.AddTransient<IGithubService, GithubService>();
         services.AddTransient<ITelegramCommandHandlerService, TelegramCommandHandlerService>();

GrammarNazi.Core/Clients/GeminiApiClient.cs

@@ -0,0 +1,38 @@
+using GrammarNazi.Domain.Clients;
+using GrammarNazi.Domain.Entities.GeminiAPI;
+using GrammarNazi.Domain.Entities.Settings;
+using Microsoft.Extensions.Options;
+using Newtonsoft.Json;
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Threading.Tasks;
+
+namespace GrammarNazi.Core.Clients;
+
+public class GeminiApiClient(IHttpClientFactory httpClientFactory, IOptions<GeminiApiSettings> options) : IGeminiApiClient
+{
+    private readonly string _apiKey = options.Value.ApiKey;
+
+    public async Task<GenerateContentResponse> GenerateContent(string promt)
+    {
+        var httpClient = httpClientFactory.CreateClient("geminiApi");
+
+        var request = new HttpRequestMessage(HttpMethod.Post, $"v1beta/models/gemini-1.5-flash:generateContent?key={_apiKey}")
+        {
+            Content = JsonContent.Create(GenerateContentRequest.CreateRequestObject(promt))
+        };
+
+        var response = await httpClient.SendAsync(request);
+
+        if (response.StatusCode != HttpStatusCode.OK)
+        {
+            throw new InvalidOperationException($"Unsuccessful Gemini API response {response.StatusCode}", new(await response.Content.ReadAsStringAsync()));
+        }
+
+        var content = await response.Content.ReadAsStringAsync();
+
+        return JsonConvert.DeserializeObject<GenerateContentResponse>(content);
+    }
+}

GrammarNazi.Core/Extensions/ServiceCollectionExtensions.cs

@@ -23,6 +23,7 @@ public static IServiceCollection AddNamedHttpClients(this IServiceCollection ser
         serviceCollection.AddHttpClient("languageToolApi", c => c.BaseAddress = new Uri("https://languagetool.org/"));
         serviceCollection.AddHttpClient("yandexSpellerApi", c => c.BaseAddress = new Uri("https://speller.yandex.net/"));
         serviceCollection.AddHttpClient("sentimApi", c => c.BaseAddress = new Uri("https://sentim-api.herokuapp.com/"));
+        serviceCollection.AddHttpClient("geminiApi", c => c.BaseAddress = new Uri("https://generativelanguage.googleapis.com/"));
 
         var meaningCloudSettings = serviceCollection.BuildServiceProvider().GetService<IOptions<MeaningCloudSettings>>().Value;
 

GrammarNazi.Core/Services/GrammarServices/GeminiApiService.cs

@@ -0,0 +1,73 @@
+using GrammarNazi.Core.Extensions;
+using GrammarNazi.Domain.Clients;
+using GrammarNazi.Domain.Entities;
+using GrammarNazi.Domain.Enums;
+using GrammarNazi.Domain.Services;
+using Newtonsoft.Json;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace GrammarNazi.Core.Services.GrammarServices;
+
+public class GeminiApiService(IGeminiApiClient geminiApiClient) : BaseGrammarService, IGrammarService
+{
+    public GrammarAlgorithms GrammarAlgorith => GrammarAlgorithms.Gemini;
+
+    public async Task<GrammarCheckResult> GetCorrections(string text)
+    {
+        var prompt = GetCorrectionPrompt(text);
+
+        var result = await geminiApiClient.GenerateContent(prompt);
+
+        if (result.Candidates.Count == 0)
+        {
+            // Empty result received
+            return new(default);
+        }
+
+        var resultJsonString = result.Candidates.First().Content.Parts.FirstOrDefault()?.Text;
+
+        if (string.IsNullOrEmpty(resultJsonString))
+        {
+            // Empty result received
+            return new(default);
+        }
+
+        var cleanedJson = resultJsonString.Replace("```json", "").Replace("```", "").Trim();
+
+        var grammarCorrections = JsonConvert.DeserializeObject<IEnumerable<GrammarCorrection>>(cleanedJson);
+
+        if (!grammarCorrections.Any())
+        {
+            // No corrections
+            return new(default);
+        }
+
+        return new(grammarCorrections.Where(x => x.PossibleReplacements.Any()));
+    }
+
+    private string GetCorrectionPrompt(string text)
+    {
+        var languageSection = SelectedLanguage == SupportedLanguages.Auto
+            ? "Auto detect the language"
+            : $"The language is {SelectedLanguage.GetDescription()}";
+
+        return @$"Analyze the following text for any grammar, spelling, or orthographic errors. For each mistake, provide the result in the JSON format below. {languageSection}.
+                Build the results in that same language. If the word doesn't have possibleReplacements, don't add it to the results. 
+
+        [{{    
+
+          ""wrongWord"": """",    
+
+          ""message"": """",    
+
+          ""possibleReplacements"": [""""]    
+
+        }}]    
+
+        Here is the text for analysis: 
+
+        {text}";
+    }
+}

GrammarNazi.Domain/Clients/IGeminiApiClient.cs

@@ -0,0 +1,9 @@
+using GrammarNazi.Domain.Entities.GeminiAPI;
+using System.Threading.Tasks;
+
+namespace GrammarNazi.Domain.Clients;
+
+public interface IGeminiApiClient
+{
+    Task<GenerateContentResponse> GenerateContent(string promt);
+}

GrammarNazi.Domain/Entities/GeminiAPI/GenerateContentRequest.cs

@@ -0,0 +1,42 @@
+using Newtonsoft.Json;
+using System.Collections.Generic;
+
+namespace GrammarNazi.Domain.Entities.GeminiAPI;
+
+public class GenerateContentRequest
+{
+    [JsonProperty("contents")]
+    public List<Content> Contents { get; set; }
+
+    public static GenerateContentRequest CreateRequestObject(string promt)
+    {
+        return new()
+        {
+            Contents = 
+            [
+                new() 
+                {
+                    Parts = 
+                    [
+                        new() 
+                        {
+                            Text = promt
+                        }
+                    ]
+                }
+            ]
+        };
+    }
+}
+
+public class Content
+{
+    [JsonProperty("parts")]
+    public List<Part> Parts { get; set; }
+}
+
+public class Part
+{
+    [JsonProperty("text")]
+    public string Text { get; set; }
+}

GrammarNazi.Domain/Entities/GeminiAPI/GenerateContentResponse.cs

@@ -0,0 +1,73 @@
+using Newtonsoft.Json;
+using System.Collections.Generic;
+
+namespace GrammarNazi.Domain.Entities.GeminiAPI;
+
+public class GenerateContentResponse
+{
+    [JsonProperty("candidates")]
+    public List<Candidate> Candidates { get; set; }
+
+    [JsonProperty("usageMetadata")]
+    public UsageMetadata UsageMetadata { get; set; }
+
+    [JsonProperty("modelVersion")]
+    public string ModelVersion { get; set; }
+}
+
+public class Candidate
+{
+    [JsonProperty("content")]
+    public ContentResponse Content { get; set; }
+
+    [JsonProperty("finishReason")]
+    public string FinishReason { get; set; }
+
+    [JsonProperty("avgLogprobs")]
+    public decimal AvgLogprobs { get; set; }
+}
+
+public class CandidatesTokensDetail
+{
+    [JsonProperty("modality")]
+    public string Modality { get; set; }
+
+    [JsonProperty("tokenCount")]
+    public int TokenCount { get; set; }
+}
+
+public class ContentResponse
+{
+    [JsonProperty("parts")]
+    public List<Part> Parts { get; set; }
+
+    [JsonProperty("role")]
+    public string Role { get; set; }
+}
+
+public class PromptTokensDetail
+{
+    [JsonProperty("modality")]
+    public string Modality { get; set; }
+
+    [JsonProperty("tokenCount")]
+    public int TokenCount { get; set; }
+}
+
+public class UsageMetadata
+{
+    [JsonProperty("promptTokenCount")]
+    public int PromptTokenCount { get; set; }
+
+    [JsonProperty("candidatesTokenCount")]
+    public int CandidatesTokenCount { get; set; }
+
+    [JsonProperty("totalTokenCount")]
+    public int TotalTokenCount { get; set; }
+
+    [JsonProperty("promptTokensDetails")]
+    public List<PromptTokensDetail> PromptTokensDetails { get; set; }
+
+    [JsonProperty("candidatesTokensDetails")]
+    public List<CandidatesTokensDetail> CandidatesTokensDetails { get; set; }
+}

GrammarNazi.Domain/Entities/Settings/GeminiApiSettings.cs

@@ -0,0 +1,6 @@
+namespace GrammarNazi.Domain.Entities.Settings;
+
+public class GeminiApiSettings
+{
+    public string ApiKey { get; set; }
+}

GrammarNazi.Domain/Enums/GrammarAlgorithms.cs

@@ -14,5 +14,8 @@ public enum GrammarAlgorithms
     YandexSpellerApi = 3,
 
     [Description("Datamuse API")]
-    DatamuseApi = 4
+    DatamuseApi = 4,
+
+    [Description("Gemini")]
+    Gemini = 5
 }

GrammarNazi.Tests/Services/TelegramCommandHandlerServiceTests.cs

@@ -68,6 +68,7 @@ public async Task HandleCallBackQuery_LanguageChange_Should_ChangeSelectedLangua
     [InlineData("GrammarAlgorithms.LanguageToolApi", GrammarAlgorithms.LanguageToolApi)]
     [InlineData("GrammarAlgorithms.YandexSpellerApi", GrammarAlgorithms.YandexSpellerApi)]
     [InlineData("GrammarAlgorithms.InternalAlgorithm", GrammarAlgorithms.InternalAlgorithm)]
+    [InlineData("GrammarAlgorithms.Gemini", GrammarAlgorithms.Gemini)]
     public async Task HandleCallBackQuery_AlgorithmChange_Should_ChangeSelectedAlgorithm(string callBackQueryData, GrammarAlgorithms grammarAlgorithm)
     {
         // Arrange