In which nuget package can I find the Microsoft.KernelMemory.Aspire extensions?

[v-croft]

I have not been able to find the Aspire extensions in a nuget package and want to avoid messy workarounds (based on KM code) for automated build scenarios.
Are these published somewhere?
Much appreciated.

[dluc]

hi @SophisticatedConsulting, the Aspire extensions are not published, they are still to experimental and insufficiently tested to be ready. I'd suggest taking the code and seeing it if works, there's a chance they work only locally and not for all deployments.

[v-croft]

Hi @dluc.
I was able to get the following to work both locally and published in Azure.

I was not able resolve:

1. Using a qdrant service provisioned in Aspire - it needed to be created manually with the connection string supplied as a secret
2. Using an Azure storage service provisioned in Aspire - whilst this works in development, the default service provisioned by Aspire does not allow connection string based access and I was not able to configure KM to connect using "AzureIdentity"
3. I also had to pass the url for the KM container as an environment parameter as this was the only way I could retrieve it in the API service.
4. I have not tried to find a way of provisioning the Azure Embedding and Text LLMs.

In conclusion, the existing extensions work on this basis, but KM could be more Aspire friendly (as per other discussions), i.e. supporting provisioned services (creating services outside of Aspire defeats the point!)

Hope this helps.

Do let me know if I am missing anything.

using Microsoft.Extensions.Configuration;
using System.Text.RegularExpressions;
using Microsoft.KernelMemory;
using Microsoft.KernelMemory.Aspire;


// Method to retrieve connection string parameters for KM config
static string GetConnectionStringPart(IResourceWithConnectionString resource, string pattern)
{
    var valueTask = resource.ConnectionStringExpression.GetValueAsync(default);
    if (!valueTask.IsCompleted)
    {
        valueTask.AsTask().Wait();
    }
    string? value = valueTask.Result;
    return value == null ? string.Empty : Regex.Match(value, pattern).Groups.Cast<Group>().Skip(1).FirstOrDefault()?.Value ?? string.Empty;
}

// Containers
const string KMDockerImage = "kernelmemory/service";
const string KMDockerTag = "latest";
const string QdrantImage = "qdrant/qdrant";

// Get configuration from app.settings
AzureBlobsConfig azureBlobsConfig = new();
AzureOpenAIConfig azureOpenAIEmbeddingConfig = new();
AzureOpenAIConfig azureOpenAITextConfig = new();
QdrantConfig s_azurequadConfig = new();
AzureQueuesConfig azureQueuesConfig = new();

new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.AddJsonFile("appsettings.development.json", optional: true)
    .AddJsonFile("appsettings.Development.json", optional: true)
    .Build()
    .BindSection("KernelMemory:DataIngestion:TextPartitioning", azureOpenAIEmbeddingConfig)
    .BindSection("KernelMemory:Services:AzureOpenAIEmbedding", azureOpenAIEmbeddingConfig)
    .BindSection("KernelMemory:Services:AzureOpenAIText", azureOpenAITextConfig)
    .BindSection("KernelMemory:Services:AzureBlobs", azureBlobsConfig)
    .BindSection("KernelMemory:Services:AzureQueues", azureQueuesConfig);

// Start build
// -----------
var builder = DistributedApplication.CreateBuilder(args);

// Get Secrets
var azureOpenAITextAPIKey = builder.AddParameter("AzureOpenAITextAPIKey", secret: true);
var azureOpenAIEmbeddingAPIKey = builder.AddParameter("AzureOpenAIEmbeddingAPIKey", secret: true);

// Get storage service
var docBlobs = builder.AddConnectionString("docBlobs");


// Qdrant Vector DB setup
// ----------------------
IResourceBuilder<QdrantServerResource> qdrant = default;
EndpointReference qdrantEndpointRef = default;
IResourceBuilder<ParameterResource> qdrantEndpointParam = default;
IResourceBuilder<ParameterResource> qdrantAPIKey = default;

if (builder.ExecutionContext.IsRunMode)
{
    qdrant = builder.AddQdrant("qdrant")
        .WithHttpEndpoint(targetPort: 6333, name: "qdrant")
        .WithDataVolume();

    // Find Qdrant endpoint and pass the value to KM below
    qdrantEndpointRef = qdrant.GetEndpoint("qdrant");
}
else
{
    qdrantEndpointParam = builder.AddParameter("qdrantEndpoint", secret: true);
    qdrantAPIKey = builder.AddParameter("qdrantAPIKey", secret: true);
}

// Kernel-Memory setup
// ------------------------
IResourceBuilder<ContainerResource> kernelMemoryService = builder.AddContainer("kernelmemory", KMDockerImage, tag: builder.ExecutionContext.IsRunMode ? $"{KMDockerTag}-arm64" : KMDockerTag)
    .WithHttpEndpoint(targetPort: 9001, name: "http")

    // Global KM settings
#if DEBUG
    .WithEnvironment("ASPNETCORE_ENVIRONMENT", "Development")
    .WithEnvironment("KernelMemory__Service__OpenApiEnabled", "true")
#endif
    .WithEnvironment("KernelMemory__Retrieval__SearchClient__AnswerTokens", "1500")
    .WithEnvironment("KernelMemory__Retrieval__MaxMatchesCount", "100")

    // Storage configuration
    .WithKmDocumentStorageEnvironment("AzureBlobs", azureBlobsConfig)
    .WithEnvironment("KernelMemory__Services__AzureBlobs__ConnectionString", docBlobs)

    // Queue configuration
    .WithKmOrchestrationEnvironment("AzureQueues", azureQueuesConfig)
    .WithEnvironment("KernelMemory__Services__AzureQueues__ConnectionString", docBlobs)

    // Embeddings model
    .WithKmTextEmbeddingGenerationEnvironment("AzureOpenAIEmbedding", azureOpenAIEmbeddingConfig)
    .WithEnvironment("KernelMemory__Services__AzureOpenAIEmbedding__APIKey", azureOpenAIEmbeddingAPIKey)

    // Text Gen Model
    .WithKmTextGenerationEnvironment("AzureOpenAIText", azureOpenAITextConfig)
    .WithEnvironment("KernelMemory__Services__AzureOpenAIText__APIKey", azureOpenAITextAPIKey)

    // Vector DB configuration - Qdrant settings
    .WithEnvironment("KernelMemory__DataIngestion__MemoryDbTypes__0", "Qdrant")
    .WithEnvironment("KernelMemory__Retrieval__MemoryDbType", "Qdrant");

if (builder.ExecutionContext.IsRunMode) {
    kernelMemoryService.WithEnvironment("KernelMemory__Services__Qdrant__Endpoint", qdrantEndpointRef!)
        .WithEnvironment("KernelMemory__Services__Qdrant__APIKey",
            () => GetConnectionStringPart(qdrant!.Resource, "Key=([^;]+)"))
        .WaitFor(qdrant);
}
else
{
    kernelMemoryService.WithEnvironment("KernelMemory__Services__Qdrant__Endpoint", qdrantEndpointParam!)
        .WithEnvironment("KernelMemory__Services__Qdrant__APIKey", qdrantAPIKey!);
}

// Find Kernel Memory endpoint
var kernelMemoryEndpoint = kernelMemoryService.GetEndpoint("http");

// Api setup
// -------------
var apiService = builder.AddProject<Projects.InnovationOps_ApiService>("apiservice")
    .WithReference(docBlobs)
    .WithEnvironment("KernelMemoryEndPoint", kernelMemoryEndpoint)
    .WaitFor(kernelMemoryService);

// Web app setup
// -------------
builder.AddProject<Projects.InnovationOps_Web>("webfrontend")
    .WithExternalHttpEndpoints()
    .WithReference(apiService)
    .WaitFor(apiService);

builder.Build().Run();