xSaherElmAiApi/Providers/XAiEmbeddingServiceBase.cs

using System;
using OpenAI;
using System.Linq;
using OllamaSharp;
using System.Threading;
using xAiApi.Constants;
using xAiModels.Models;
using xAiApi.Extensions;
using xAiApi.Interfaces;
using xAiService.Helpers;
using System.ClientModel;
using xCommons.Providers;
using xCommons.Extensions;
using xAiModels.Constants;
using xAiModels.Extensions;
using xAiModels.Interfaces;
using xAiApi.Configurations;
using xExceptions.Constants;
using System.Threading.Tasks;
using xFileService.Interfaces;
using Microsoft.Extensions.AI;
using System.Collections.Generic;
using Microsoft.Extensions.Logging;
using xAiApi.Interfaces.Extractors;
using System.ClientModel.Primitives;

namespace xAiApi.Providers
{
    /// <summary>
    /// Base Embedding Provider Service ...
    /// </summary>
    public abstract class XAiEmbeddingServiceBase : XAIServiceBase, IXAiEmbeddingServiceBase
    {
        private readonly IXFileProvider fileProvider;
        private readonly XAiModelDescriptor descriptor;
        private readonly ILogger<XAiEmbeddingServiceBase> logger;

        protected XAiEmbeddingServiceBase(
            IXFileProvider fileProvider,
            IXAiDataProvider dataProvider,
            XAiApiConfiguration configuration,
            XValidationProvider validationProvider,
            ILogger<XAiEmbeddingServiceBase> logger,
            IXFileContentExtractor fileContentExtractor,
            string embeddingModelName = XAiApiConstants.XAiEmbeddingModelName
        ) : base(
            fileProvider,
            dataProvider,
            logger,
            configuration,
            validationProvider,
            fileContentExtractor,
            null
        )
        {
            //
            // Prepare Embedding Model Descriptor ...
            descriptor = configuration.GetModel(embeddingModelName);
            if (!descriptor.IsValid())
            {
                XException.InvalidConfiguration.Throw();
            }

            this.fileProvider = fileProvider;

            //
            this.logger = logger;
        }

        /// <summary>
        /// Embedding Specified String ...
        /// </summary>
        /// <param name="content"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<float[]> Embedding(
            string content,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Validate ...
            if (content.IsNullOrEmpty())
            {
                XException.InvalidArgs.Throw();
            }

            //
            using var generator = GetEmbeddingGenerator();

            //
            GeneratedEmbeddings<Embedding<float>> response = null;
            response = await generator.GenerateAsync(
                values: [content],
                cancellationToken: cancellationToken
            );

            //
            if (response.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            // Generae Result ...
            var result = response
                .First()?
                .Vector
                .ToArray()
               ?? [];
            if (result.Length == 0)
            {
                XException.ActionFailed.Throw();
            }

            //
            // Normalize ...
            VectorHelper.Normalize(result);

            //
            return result;
        }

        /// <summary>
        /// Embedding Specified Batch ...
        /// </summary>
        /// <param name="batch"></param>
        /// <param name="cancellationToken"></param>
        /// <returns></returns>
        public virtual async Task<IReadOnlyList<float[]>> Embeddings(
            string[] batch,
            CancellationToken cancellationToken = default
        )
        {
            //
            // Validate ...
            if (!batch.HasChild() ||
                !batch.All(x => !x.IsNullOrEmpty())
            )
            {
                XException.InvalidArgs.Throw();
            }

            //
            using var generator = GetEmbeddingGenerator();

            //
            GeneratedEmbeddings<Embedding<float>> response = null;
            response = await generator.GenerateAsync(
                values: [.. batch],
                cancellationToken: cancellationToken
            );

            //
            if (response.IsNullOrDefault())
            {
                XException.ActionFailed.Throw();
            }

            //
            var result = response
                .Select(e => e.Vector.ToArray())
                .ToList();

            //
            // Normalize ...
            foreach (var vector in result)
            {
                VectorHelper.Normalize(vector);
            }

            //
            return result;
        }

        /// <summary>
        /// Embedding Generator ...
        /// </summary>
        /// <returns></returns>
        public IEmbeddingGenerator<string, Embedding<float>> GetEmbeddingGenerator()
        {
            //
            IEmbeddingGenerator<string, Embedding<float>> result = null;

            //
            if (!descriptor.IsValid())
            {
                XException.InvalidData.Throw("Invalid Embedding Model ...");
            }

            //
            switch (descriptor.Provider)
            {
                //
                case XAiModelProviderType.OpenAI:
                    //
                    var openAiClient = new OpenAIClient(
                        new ApiKeyCredential(descriptor.ApiKey.IsNullOrEmpty() ? XAiApiConstants.XOpenAINoKey : descriptor.ApiKey),
                        new OpenAIClientOptions
                        {
                            Endpoint = new Uri(descriptor.Url),
                            Transport = new HttpClientPipelineTransport(descriptor.Url.GetHttpClient())
                        }
                    );
                    result = openAiClient
                        .GetEmbeddingClient(descriptor.LLM)
                        .AsIEmbeddingGenerator();
                    break;

                //
                case XAiModelProviderType.Ollama:
                    //
                    var ollamaClient = new OllamaApiClient(new Uri(descriptor.Url));
                    result = ollamaClient;
                    break;
            }

            //
            if (result.IsNull())
            {
                XException.InvalidData.Throw("Invalid Embedding Model ...");
            }

            //
            return result;
        }
    }
}