Deepseek integration (#69)

Madzionator · Piotr Stachaczynski · web-flow · commit f6bc2aa78814 · 2025-07-22T09:10:39.000+02:00
* Add DeepSeek LLM backend integration

* Add DeepSeek models and update image gen factory

* Add DeepSeek reasoning support

* Improve method to fetch current models for OpenAi compatible models

* versioning

* PR fixes

* PR fixes 2

* infer fix + clean

---------

Co-authored-by: Piotr Stachaczynski &lt;piotr.stachaczynski@priva.com&gt;
diff --git a/Examples/Examples/Chat/ChatWithReasoningDeepSeekExample.cs b/Examples/Examples/Chat/ChatWithReasoningDeepSeekExample.cs
@@ -0,0 +1,18 @@
+using Examples.Utils;
+using MaIN.Core.Hub;
+
+namespace Examples;
+
+public class ChatWithReasoningDeepSeekExample : IExample
+{
+    public async Task Start()
+    {
+        DeepSeekExample.Setup(); //We need to provide DeepSeek API key
+        Console.WriteLine("(DeepSeek) ChatExample with reasoning is running!");
+
+        await AIHub.Chat()
+            .WithModel("deepseek-reasoner") // a model that supports reasoning
+            .WithMessage("What chill pc game do you recommend?")
+            .CompleteAsync(interactive: true);
+    }
+}
diff --git a/Examples/Examples/Program.cs b/Examples/Examples/Program.cs
@@ -66,6 +66,7 @@ static void RegisterExamples(IServiceCollection services)
     services.AddTransient<ChatExampleGemini>();
     services.AddTransient<ChatWithImageGenGeminiExample>();
     services.AddTransient<ChatWithFilesExampleGemini>();
+    services.AddTransient<ChatWithReasoningDeepSeekExample>();
 }
 
 async Task RunSelectedExample(IServiceProvider serviceProvider)
@@ -151,6 +152,7 @@ public class ExampleRegistry(IServiceProvider serviceProvider)
             ("\u25a0 Gemini Chat", serviceProvider.GetRequiredService<ChatExampleGemini>()),
             ("\u25a0 Gemini Chat with image", serviceProvider.GetRequiredService<ChatWithImageGenGeminiExample>()),
             ("\u25a0 Gemini Chat with files", serviceProvider.GetRequiredService<ChatWithFilesExampleGemini>()),
+            ("\u25a0 DeepSeek Chat with reasoning", serviceProvider.GetRequiredService<ChatWithReasoningDeepSeekExample>()),
             ("\u25a0 McpClient example", serviceProvider.GetRequiredService<McpExample>()),
             ("\u25a0 McpAgent example", serviceProvider.GetRequiredService<McpAgentsExample>())
 
diff --git a/Examples/Examples/Utils/DeepSeekExample.cs b/Examples/Examples/Utils/DeepSeekExample.cs
@@ -0,0 +1,16 @@
+using MaIN.Core;
+using MaIN.Domain.Configuration;
+
+namespace Examples.Utils;
+
+public class DeepSeekExample
+{
+    public static void Setup()
+    {
+        MaINBootstrapper.Initialize(configureSettings: (options) =>
+        {
+            options.BackendType = BackendType.DeepSeek;
+            options.DeepSeekKey = "<YOUR_DEEPSEEK_KEY>";
+        });
+    }
+}
diff --git a/Releases/0.3.0.md b/Releases/0.3.0.md
@@ -0,0 +1,4 @@
+# 0.3.10 release
+
+DeepSeek integration has been added, bringing reasoning support.
+The method for fetching current models across all OpenAI-compatible services has also been improved.
diff --git a/src/MaIN.Core/.nuspec b/src/MaIN.Core/.nuspec
@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>MaIN.NET</id>
-    <version>0.2.9</version>
+    <version>0.3.0</version>
     <authors>Wisedev</authors>
     <owners>Wisedev</owners>
     <icon>favicon.png</icon>
diff --git a/src/MaIN.Domain/Configuration/MaINSettings.cs b/src/MaIN.Domain/Configuration/MaINSettings.cs
@@ -10,6 +10,7 @@ public class MaINSettings
     public string? ImageGenUrl { get; set; }
     public string? OpenAiKey { get; set; }
     public string? GeminiKey { get; set; }
+    public string? DeepSeekKey { get; set; }
     public MongoDbSettings? MongoDbSettings { get; set; }
     public FileSystemSettings? FileSystemSettings { get; set; }
     public SqliteSettings? SqliteSettings { get; set; }
@@ -20,5 +21,6 @@ public enum BackendType
 {
     Self = 0,
     OpenAi = 1,
-    Gemini = 2
+    Gemini = 2,
+    DeepSeek = 3,
 }
diff --git a/src/MaIN.Domain/Models/SupportedModels.cs b/src/MaIN.Domain/Models/SupportedModels.cs
@@ -195,6 +195,11 @@ public static Model GetEmbeddingModel() =>
             DownloadUrl = "https://huggingface.co/Inza124/Nomic/resolve/main/Nomic-maIN.gguf?download=true",
         };
 
+    public static bool IsModelSupported(string name) =>
+        Models.Any(x => x.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)
+                        || x.Name.Replace(':', '-').Equals(name,
+                            StringComparison.InvariantCultureIgnoreCase));
+    
     public static Model GetModel(string path, string? name)
     {
         var model = Models.FirstOrDefault(x => x.Name.Equals(name, StringComparison.InvariantCultureIgnoreCase)
diff --git a/src/MaIN.InferPage/Components/Pages/Home.razor b/src/MaIN.InferPage/Components/Pages/Home.razor
@@ -208,7 +208,12 @@
                 ? AIHub.Chat().WithCustomModel(model: Utils.Model!, path: Utils.Path)
                 : AIHub.Chat().WithModel(Utils.Model!); //If that grows with different chat types we can consider switch ex
 
-        if (!Utils.OpenAi)
+        if (Utils.DeepSeek)
+        {
+            _reasoning = Utils.Model!.ToLower().Contains("reasoner");
+            Utils.Reason = _reasoning;
+        }
+        else if (!Utils.OpenAi)
         {
             _reasoning = !Utils.Visual && KnownModels.GetModel(Utils.Model!).HasReasoning();
             Utils.Reason = _reasoning;
diff --git a/src/MaIN.InferPage/Program.cs b/src/MaIN.InferPage/Program.cs
@@ -1,5 +1,7 @@
+using System.Net.Mime;
 using MaIN.Core;
 using MaIN.Domain.Configuration;
+using MaIN.Domain.Models;
 using Microsoft.FluentUI.AspNetCore.Components;
 using MaIN.InferPage.Components;
 using Utils = MaIN.InferPage.Utils;
@@ -57,6 +59,12 @@
                 apiKeyVariable = "GEMINI_API_KEY";
                 apiName = "Gemini";
                 break;
+            
+            case "deepseek":
+                Utils.DeepSeek = true;
+                apiKeyVariable = "DEEPSEEK_API_KEY";
+                apiName = "Deepseek";
+                break;
         }
 
         var key = Environment.GetEnvironmentVariable(apiKeyVariable);
@@ -88,8 +96,21 @@
         settings.BackendType = BackendType.Gemini;
     });
 }
+else if (Utils.DeepSeek)
+{
+    builder.Services.AddMaIN(builder.Configuration, settings =>
+    {
+        settings.BackendType = BackendType.DeepSeek;
+    });
+}
 else
 {
+    if (Utils.Path == null && !KnownModels.IsModelSupported(Utils.Model!))
+    {
+        Console.WriteLine($"Model: {Utils.Model} is not supported");
+        Environment.Exit(0);
+    }
+    
     builder.Services.AddMaIN(builder.Configuration);
 }
 
diff --git a/src/MaIN.InferPage/Utils.cs b/src/MaIN.InferPage/Utils.cs
@@ -9,6 +9,7 @@ public static class Utils
     private static readonly string[] VisualModels = ["FLUX.1_Shnell", "FLUX.1", "dall-e-3", "dall-e", "imagen", "imagen-3"]; //user might type different names
     public static bool OpenAi { get; set; }
     public static bool Gemini { get; set; }
+    public static bool DeepSeek { get; set; }
     public static string? Path { get; set; }
     public static bool Reason { get; set; }
 }
diff --git a/src/MaIN.Services/Constants/ServiceConstants.cs b/src/MaIN.Services/Constants/ServiceConstants.cs
@@ -8,6 +8,7 @@ public static class HttpClients
         public const string ImageGenClient = "ImageGenClient";
         public const string OpenAiClient = "OpenAiClient";
         public const string GeminiClient = "GeminiClient";
+        public const string DeepSeekClient = "DeepSeekClient";
         public const string ImageDownloadClient = "ImageDownloadClient";
         public const string ModelContextDownloadClient = "ModelContextDownloadClient";
     }
@@ -21,6 +22,9 @@ public static class ApiUrls
         public const string GeminiImageGenerations = "https://generativelanguage.googleapis.com/v1beta/openai/images/generations";
         public const string GeminiOpenAiChatCompletions = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"; 
         public const string GeminiModels = "https://generativelanguage.googleapis.com/v1beta/models";
+
+        public const string DeepSeekOpenAiChatCompletions = "https://api.deepseek.com/v1/chat/completions";
+        public const string DeepSeekModels = "https://api.deepseek.com/models";
     }
 
     public static class Messages
diff --git a/src/MaIN.Services/Services/LLMService/DeepSeekService.cs b/src/MaIN.Services/Services/LLMService/DeepSeekService.cs
@@ -0,0 +1,89 @@
+using MaIN.Domain.Configuration;
+using MaIN.Domain.Entities;
+using MaIN.Services.Services.Abstract;
+using Microsoft.Extensions.Logging;
+using MaIN.Services.Services.LLMService.Memory;
+using MaIN.Services.Constants;
+using MaIN.Services.Services.Models;
+using MaIN.Domain.Models;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace MaIN.Services.Services.LLMService;
+
+public sealed class DeepSeekService(
+    MaINSettings settings,
+    INotificationService notificationService,
+    IHttpClientFactory httpClientFactory,
+    IMemoryFactory memoryFactory,
+    IMemoryService memoryService,
+    ILogger<OpenAiService>? logger = null)
+    : OpenAiCompatibleService(notificationService, httpClientFactory, memoryFactory, memoryService, logger)
+{
+    private readonly MaINSettings _settings = settings ?? throw new ArgumentNullException(nameof(settings));
+    private readonly IHttpClientFactory _httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
+
+    protected override string HttpClientName => ServiceConstants.HttpClients.DeepSeekClient;
+    protected override string ChatCompletionsUrl => ServiceConstants.ApiUrls.DeepSeekOpenAiChatCompletions;
+    protected override string ModelsUrl => ServiceConstants.ApiUrls.DeepSeekModels;
+
+    protected override string GetApiKey()
+    {
+        return _settings.DeepSeekKey ?? Environment.GetEnvironmentVariable("DEEPSEEK_API_KEY") ??
+            throw new InvalidOperationException("DeepSeek Key not configured");
+    }
+
+    protected override void ValidateApiKey()
+    {
+        if (string.IsNullOrEmpty(_settings.DeepSeekKey) && string.IsNullOrEmpty(Environment.GetEnvironmentVariable("DEEPSEEK_API_KEY")))
+        {
+            throw new InvalidOperationException("DeepSeek Key not configured");
+        }
+    }
+
+    public override Task<ChatResult?> AskMemory(
+        Chat chat,
+        ChatMemoryOptions memoryOptions,
+        CancellationToken cancellationToken = default)
+    {
+        throw new NotSupportedException("Embeddings are not supported by the DeepSeek model. Document reading requires embedding support.");
+    }
+
+    protected override LLMTokenValue? ProcessChatCompletionChunk(string data)
+    {
+        var chunk = JsonSerializer.Deserialize<ChatCompletionChunk>(data,
+            new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
+
+        var contentValue = chunk?.Choices?.FirstOrDefault()?.Delta?.Content;
+        if (!string.IsNullOrEmpty(contentValue))
+        {
+            return new LLMTokenValue { Text = contentValue, Type = TokenType.Message };
+        }
+
+        var reasoningContentValue = chunk?.Choices?.FirstOrDefault()?.Delta?.ReasoningContent;
+        if (!string.IsNullOrEmpty(reasoningContentValue))
+        {
+            return new LLMTokenValue { Text = reasoningContentValue, Type = TokenType.Reason };
+        }
+
+        return null;
+    }
+}
+
+file class ChatCompletionChunk
+{
+    public List<ChoiceChunk>? Choices { get; set; }
+}
+
+file class ChoiceChunk
+{
+    public Delta? Delta { get; set; }
+}
+
+file class Delta
+{
+    [JsonPropertyName("content")]
+    public string? Content { get; set; }
+    [JsonPropertyName("reasoning_content")]
+    public string? ReasoningContent { get; set; } // property specific for DeepSeek
+}
diff --git a/src/MaIN.Services/Services/LLMService/Factory/ImageGenServiceFactory.cs b/src/MaIN.Services/Services/LLMService/Factory/ImageGenServiceFactory.cs
@@ -15,6 +15,7 @@ public IImageGenService CreateService(BackendType backendType)
                 serviceProvider.GetRequiredService<MaINSettings>()),
             BackendType.Gemini => new GeminiImageGenService(serviceProvider.GetRequiredService<IHttpClientFactory>(),
                 serviceProvider.GetRequiredService<MaINSettings>()),
+            BackendType.DeepSeek => throw new NotSupportedException("DeepSeek does not support image generation."),
             BackendType.Self => new ImageGenService(serviceProvider.GetRequiredService<IHttpClientFactory>(),
                 serviceProvider.GetRequiredService<MaINSettings>()),
             
diff --git a/src/MaIN.Services/Services/LLMService/Factory/LLMServiceFactory.cs b/src/MaIN.Services/Services/LLMService/Factory/LLMServiceFactory.cs
@@ -25,7 +25,15 @@ public ILLMService CreateService(BackendType backendType)
                 serviceProvider.GetRequiredService<IMemoryFactory>(),
                 serviceProvider.GetRequiredService<IMemoryService>()),
 
-            BackendType.Self => new LLMService(serviceProvider.GetRequiredService<MaINSettings>(),
+            BackendType.DeepSeek => new DeepSeekService(
+                serviceProvider.GetRequiredService<MaINSettings>(),
+                serviceProvider.GetRequiredService<INotificationService>(),
+                serviceProvider.GetRequiredService<IHttpClientFactory>(),
+                serviceProvider.GetRequiredService<IMemoryFactory>(),
+                serviceProvider.GetRequiredService<IMemoryService>()),
+
+            BackendType.Self => new LLMService(
+                serviceProvider.GetRequiredService<MaINSettings>(),
                 serviceProvider.GetRequiredService<INotificationService>(),
                 serviceProvider.GetRequiredService<IMemoryService>(),
                 serviceProvider.GetRequiredService<IMemoryFactory>()),
diff --git a/src/MaIN.Services/Services/LLMService/Memory/MemoryFactory.cs b/src/MaIN.Services/Services/LLMService/Memory/MemoryFactory.cs
@@ -1,12 +1,8 @@
-using System.Diagnostics.CodeAnalysis;
-using Elastic.Clients.Elasticsearch.Core.GetScriptContext;
 using LLama;
 using LLama.Common;
 using LLamaSharp.KernelMemory;
-using MaIN.Domain.Configuration;
 using MaIN.Domain.Entities;
 using MaIN.Domain.Models;
-using MaIN.Services.Services.LLMService.Utils;
 using Microsoft.KernelMemory;
 using Microsoft.KernelMemory.Configuration;
 using Microsoft.KernelMemory.SemanticKernel;
diff --git a/src/MaIN.Services/Services/LLMService/OpenAiCompatibleService.cs b/src/MaIN.Services/Services/LLMService/OpenAiCompatibleService.cs
diff --git a/src/MaIN.Services/Services/LLMService/OpenAiService.cs b/src/MaIN.Services/Services/LLMService/OpenAiService.cs
diff --git a/src/MaIN.Services/Services/McpService.cs b/src/MaIN.Services/Services/McpService.cs

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ public static class Utils`
`9`	`9`	`private static readonly string[] VisualModels = ["FLUX.1_Shnell", "FLUX.1", "dall-e-3", "dall-e", "imagen", "imagen-3"]; //user might type different names`
`10`	`10`	`public static bool OpenAi { get; set; }`
`11`	`11`	`public static bool Gemini { get; set; }`
	`12`	`+ public static bool DeepSeek { get; set; }`
`12`	`13`	`public static string? Path { get; set; }`
`13`	`14`	`public static bool Reason { get; set; }`
`14`	`15`	`}`