Encamina.Enmarcha.SemanticKernel.Connectors.Memory 8.1.5-preview-11

Semantic Kernel - Memory Connectors

Memory Connectors is a project that allows adding specific IMemoryStore instances. These IMemoryStore instances are used for storing and retrieving embeddings.

Setup

Nuget package

First, install NuGet. Then, install Encamina.Enmarcha.SemanticKernel.Connectors.Memory from the package manager console:

PM> Install-Package Encamina.Enmarcha.SemanticKernel.Connectors.Memory

.NET CLI:

Install .NET CLI. Next, install Encamina.Enmarcha.SemanticKernel.Connectors.Memory from the .NET CLI:

dotnet add package Encamina.Enmarcha.SemanticKernel.Connectors.Memory

How to use

First, if you want use Qdrant memory provider you need to add the QdrantOptions to your project configuration. You can achieve this by using any configuration provider. The followng code is an example of how the settings would appear using the appsettings.json file:

// ...
  "QdrantOptions": {
    "Host": "https://sample-qdrant.azurewebsites.net/", // Endpoint protocol and host
    "Port": 6333, // Endpoint port
    "VectorSize": 1536, // Vector size
    "ApiKey": "xxxxxxxxxx" // API Key used by Qdrant as a form of client authentication.
  },
// ...

If you want to use Azure AI Search as a memory provider, you need to add the AzureSearchOptions to your project configuration. You can achieve this by using any configuration provider. The following code is an example of how the settings would appear using the appsettings.json file:

// ...
  "AzureSearchOptions": {
    "Endpoint": "https://sample-searchendpoint/", // Endpoint
    "Key": "xxxxxxxxxx" // API Key used by Azure Search AI as a form of client authentication.
  },
// ...

Next, in `Program.cs` or a similar entry point file in your project, add the following code:

```csharp
// Entry point
var builder = WebApplication.CreateBuilder(new WebApplicationOptions
{
   // ...
});

// ...

// Or others configuration providers...
builder.Configuration.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); 

builder.Services.AddOptions<QdrantOptions>().Bind(builder.Configuration.GetSection(nameof(QdrantOptions)))
    .ValidateDataAnnotations()
    .ValidateOnStart();

// Adds Qdrant as IMemoryStore
services.AddQdrantMemoryStore();

// Or adds Azure AI Search as IMemoryStore
services.AddAzureAISearchMemoryStore();

If you need add both memory providers, you can use the following code:

   
   services.AddAzureAISearchNamedMemoryStore("AzureAISearchMemoryStore");  //AzureAISearchMemoryStore is the name of the memory store that you can use in the future to inject the IMemoryStore
   services.AddQdrantNamedMemoryStore("QdrantMemoryStore"); //QdrantMemoryStore is the name of the memory store that you can use in the future to inject the IMemoryStore

In the previous code, it can be observed that in the first part is necessary to add certain Qdrant configurations that are available in the Encamina.Enmarcha.Data.Qdrant.Abstractions nuget package. The last line of code corresponds to an extension method that will add the specified implementation of the IMemoryStore interface as a singleton. With this, you have Qdrant configured as the storage to save and retrieve embeddings.

After the initial configuration, we typically configure Semantic Kernel as Scoped.

builder.Services.AddScoped(sp =>
{
    var kernel = new KernelBuilder()
        .WithAzureTextEmbeddingGenerationService("<YOUR DEPLOYMENT NAME>", "<YOUR AZURE ENDPOINT>", "<YOUR API KEY>")
        //.WithOpenAITextEmbeddingGenerationService("<YOUR MODEL ID>", "<YOUR API KEY>", "<YOUR API KEY>")
        /// ...
        .Build();

    // ...

    return kernel;
});

Once configured, you can now use Semantic Kernel, and it will utilize the Qdrant storage we have previously set up (in addition to generating the embeddings).

public class MyClass
{
    private readonly Kernel kernel;

    public MyClass(Kernel kernel)
    {
        this.kernel = kernel;
    }

    public async Task MyTestMethodAsync()
    {
        await kernel.Memory.SaveInformationAsync("my-collection", "my dummy text", Guid.NewGuid().ToString());
        var memoryQueryResult = await kernel.Memory.SearchAsync("my-collection", "my similar dummy text")
            .ToListAsync(); // ToListAsync method is provided by System.Linq.Async nuget https://www.nuget.org/packages/System.Linq.Async
    }
}

If you prefer, you can inject the ISemanticTextMemory interface directly.

public class MyClass
{   
    private readonly ISemanticTextMemory semanticTextMemory;

    public MyClass(ISemanticTextMemory semanticTextMemory)
    {
        this.semanticTextMemory = semanticTextMemory;
    }

    public async Task MyTestMethodAsync()
    {
        await semanticTextMemory.SaveInformationAsync("my-collection", "my dummy text", Guid.NewGuid().ToString());
        var memoryQueryResult = await semanticTextMemory.SearchAsync("my-collection", "my similar dummy text")
            .ToListAsync(); // ToListAsync method is provided by System.Linq.Async nuget https://www.nuget.org/packages/System.Linq.Async
    }
}

If use NamedKeys, you can use the following code:

    internal class YourClassWithAzureSearch 
    {
        private readonly Kernel kernel;

        public YourClass([FromKeyedServices("Your Provider Name , fe: 'AzureAISearchMemoryStore'")]Kernel kernel)
        {
            this.kernel = kernel;
        }
    }

    internal class YourClassWithQdrant
    {
        private readonly Kernel kernel;

        public YourClass([FromKeyedServices("Your Provider Name , fe: 'QdrantMemoryStore'")]Kernel kernel)
        {
            this.kernel = kernel;
        }
    }