Changes

rag-api/Clients/Ai/CachedAiClient.cs

@@ -0,0 +1,53 @@
+using Microsoft.Extensions.Options;
+using Api.Models.Settings;
+using Api.Data.Repositories.Contracts;
+using Api.Clients.Ai.Contracts;
+
+namespace Api.Clients.Ai;
+
+public sealed class CachedAiClient : IAiClient
+{
+    private readonly RawAiClient _raw;
+    private readonly IRagRepository _repository;
+    private readonly AiSettings _settings;
+
+    public CachedAiClient(RawAiClient raw, IRagRepository repository, IOptions<AiSettings> options)
+    {
+        _raw = raw;
+        _repository = repository;
+        _settings = options.Value;
+    }
+
+    public async Task<float[]> CreateEmbeddingAsync(string input, CancellationToken ct)
+    {
+        var model = GetEmbeddingModel();
+        var textHash = HashHelper.Compute(input);
+        var cacheKey = HashHelper.Compute($"embedding:{_settings.Provider}:{model}:{textHash}");
+        var cached = await _repository.GetEmbeddingAsync(cacheKey, ct);
+        if (cached is not null) return cached;
+
+        var vector = await _raw.CreateEmbeddingAsync(input, ct);
+        await _repository.SaveEmbeddingAsync(cacheKey, model, textHash, vector, ct);
+        return vector;
+    }
+
+    public async Task<string> CreateChatCompletionAsync(string systemPrompt, string userPrompt, decimal temperature, CancellationToken ct)
+    {
+        var model = GetChatModel();
+        var cacheKey = HashHelper.Compute($"chat:{_settings.Provider}:{model}:{temperature:0.00}:{systemPrompt}:{userPrompt}");
+        var cached = await _repository.GetChatCompletionAsync(cacheKey, ct);
+        if (cached is not null) return cached;
+
+        var response = await _raw.CreateChatCompletionAsync(systemPrompt, userPrompt, temperature, ct);
+        await _repository.SaveChatCompletionAsync(cacheKey, model, temperature, response, ct);
+        return response;
+    }
+
+    private string GetEmbeddingModel() => string.Equals(_settings.Provider, "Ollama", StringComparison.OrdinalIgnoreCase)
+        ? _settings.Ollama.EmbeddingModel
+        : _settings.OpenAI.EmbeddingModel;
+
+    private string GetChatModel() => string.Equals(_settings.Provider, "Ollama", StringComparison.OrdinalIgnoreCase)
+        ? _settings.Ollama.ChatModel
+        : _settings.OpenAI.ChatModel;
+}

rag-api/Clients/Ai/Contracts/IAiClient.cs

@@ -0,0 +1,7 @@
+namespace Api.Clients.Ai.Contracts;
+
+public interface IAiClient
+{
+    Task<float[]> CreateEmbeddingAsync(string input, CancellationToken ct);
+    Task<string> CreateChatCompletionAsync(string systemPrompt, string userPrompt, decimal temperature, CancellationToken ct);
+}

rag-api/Clients/Ai/HashHelper.cs

@@ -0,0 +1,14 @@
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Api.Clients.Ai;
+
+public static class HashHelper
+{
+    public static string Compute(string value)
+    {
+        using var sha = SHA256.Create();
+        var bytes = sha.ComputeHash(Encoding.UTF8.GetBytes(value ?? string.Empty));
+        return Convert.ToHexString(bytes);
+    }
+}

rag-api/Clients/Ai/RawAiClient.cs

@@ -0,0 +1,116 @@
+using System.Net.Http.Headers;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Extensions.Options;
+using Api.Models.Settings;
+using Api.Clients.Ai.Contracts;
+
+namespace Api.Clients.Ai;
+
+public sealed class RawAiClient : IAiClient
+{
+    private readonly HttpClient _http;
+    private readonly AiSettings _settings;
+    private static readonly JsonSerializerOptions JsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull
+    };
+
+    public RawAiClient(HttpClient http, IOptions<AiSettings> options)
+    {
+        _http = http;
+        _settings = options.Value;
+    }
+
+    public async Task<float[]> CreateEmbeddingAsync(string input, CancellationToken ct)
+    {
+        return IsOllama() ? await CreateOllamaEmbeddingAsync(input, ct) : await CreateOpenAiEmbeddingAsync(input, ct);
+    }
+
+    public async Task<string> CreateChatCompletionAsync(string systemPrompt, string userPrompt, decimal temperature, CancellationToken ct)
+    {
+        return IsOllama()
+            ? await CreateOllamaChatCompletionAsync(systemPrompt, userPrompt, temperature, ct)
+            : await CreateOpenAiChatCompletionAsync(systemPrompt, userPrompt, temperature, ct);
+    }
+
+    private bool IsOllama() => string.Equals(_settings.Provider, "Ollama", StringComparison.OrdinalIgnoreCase);
+
+    private async Task<float[]> CreateOpenAiEmbeddingAsync(string input, CancellationToken ct)
+    {
+        if (string.IsNullOrWhiteSpace(_settings.OpenAI.ApiKey)) throw new InvalidOperationException("OpenAI API key is missing.");
+        using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/embeddings");
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _settings.OpenAI.ApiKey);
+        request.Content = ToJson(new { model = _settings.OpenAI.EmbeddingModel, input });
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        cts.CancelAfter(TimeSpan.FromSeconds(Math.Max(15, _settings.OpenAI.TimeoutSeconds)));
+        using var response = await _http.SendAsync(request, cts.Token);
+        var json = await response.Content.ReadAsStringAsync(cts.Token);
+        if (!response.IsSuccessStatusCode) throw new InvalidOperationException($"OpenAI embeddings failed: {(int)response.StatusCode} {json}");
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.GetProperty("data")[0].GetProperty("embedding").EnumerateArray().Select(x => x.GetSingle()).ToArray();
+    }
+
+    private async Task<string> CreateOpenAiChatCompletionAsync(string systemPrompt, string userPrompt, decimal temperature, CancellationToken ct)
+    {
+        if (string.IsNullOrWhiteSpace(_settings.OpenAI.ApiKey)) throw new InvalidOperationException("OpenAI API key is missing.");
+        using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.openai.com/v1/chat/completions");
+        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", _settings.OpenAI.ApiKey);
+        request.Content = ToJson(new
+        {
+            model = _settings.OpenAI.ChatModel,
+            temperature,
+            response_format = new { type = "json_object" },
+            messages = new[]
+            {
+                new { role = "system", content = systemPrompt },
+                new { role = "user", content = userPrompt }
+            }
+        });
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        cts.CancelAfter(TimeSpan.FromSeconds(Math.Max(15, _settings.OpenAI.TimeoutSeconds)));
+        using var response = await _http.SendAsync(request, cts.Token);
+        var json = await response.Content.ReadAsStringAsync(cts.Token);
+        if (!response.IsSuccessStatusCode) throw new InvalidOperationException($"OpenAI chat failed: {(int)response.StatusCode} {json}");
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.GetProperty("choices")[0].GetProperty("message").GetProperty("content").GetString() ?? "{}";
+    }
+
+    private async Task<float[]> CreateOllamaEmbeddingAsync(string input, CancellationToken ct)
+    {
+        var baseUrl = _settings.Ollama.BaseUrl.TrimEnd('/');
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        cts.CancelAfter(TimeSpan.FromSeconds(Math.Max(30, _settings.Ollama.TimeoutSeconds)));
+        using var response = await _http.PostAsync($"{baseUrl}/api/embeddings", ToJson(new { model = _settings.Ollama.EmbeddingModel, prompt = input }), cts.Token);
+        var json = await response.Content.ReadAsStringAsync(cts.Token);
+        if (!response.IsSuccessStatusCode) throw new InvalidOperationException($"Ollama embeddings failed: {(int)response.StatusCode} {json}");
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.GetProperty("embedding").EnumerateArray().Select(x => x.GetSingle()).ToArray();
+    }
+
+    private async Task<string> CreateOllamaChatCompletionAsync(string systemPrompt, string userPrompt, decimal temperature, CancellationToken ct)
+    {
+        var baseUrl = _settings.Ollama.BaseUrl.TrimEnd('/');
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
+        cts.CancelAfter(TimeSpan.FromSeconds(Math.Max(30, _settings.Ollama.TimeoutSeconds)));
+        using var response = await _http.PostAsync($"{baseUrl}/api/chat", ToJson(new
+        {
+            model = _settings.Ollama.ChatModel,
+            stream = false,
+            format = "json",
+            messages = new[]
+            {
+                new { role = "system", content = systemPrompt },
+                new { role = "user", content = userPrompt }
+            },
+            options = new { temperature = (float)temperature }
+        }), cts.Token);
+        var json = await response.Content.ReadAsStringAsync(cts.Token);
+        if (!response.IsSuccessStatusCode) throw new InvalidOperationException($"Ollama chat failed: {(int)response.StatusCode} {json}");
+        using var doc = JsonDocument.Parse(json);
+        return doc.RootElement.GetProperty("message").GetProperty("content").GetString() ?? "{}";
+    }
+
+    private static StringContent ToJson<T>(T payload) => new(JsonSerializer.Serialize(payload, JsonOptions), Encoding.UTF8, "application/json");
+}