Replace Qdrant with Qdrant Edge (#783)

app/MindWork AI Studio/Tools/Databases/DatabaseClientProvider.cs

@@ -1,6 +1,5 @@
-using AIStudio.Tools.Databases.Qdrant;
-using AIStudio.Tools.Rust;
 using AIStudio.Tools.Services;
+using AIStudio.Tools.Databases.VectorStore;
 
 namespace AIStudio.Tools.Databases;
 
@@ -45,6 +44,18 @@ public sealed class DatabaseClientProvider(RustService rustService, ILoggerFacto
         }
     }
 
+    public async Task<IVectorStoreClient> GetVectorStoreAsync(CancellationToken cancellationToken = default)
+    {
+        var client = await this.GetClientAsync(DatabaseRole.VECTOR_STORE, cancellationToken);
+        if (client is IVectorStoreClient vectorStore)
+            return vectorStore;
+
+        return new NoVectorStoreClient(
+            client.Name,
+            "The configured database client does not support vector store operations.",
+            client.Status);
+    }
+
     private DatabaseClient CacheIfAvailable(DatabaseRole databaseRole, DatabaseClient client)
     {
         if (!client.IsAvailable)
@@ -80,90 +91,10 @@ public sealed class DatabaseClientProvider(RustService rustService, ILoggerFacto
 
     private async Task<DatabaseClient> CreateClientAsync(DatabaseRole databaseRole, CancellationToken cancellationToken) => databaseRole switch
     {
-        DatabaseRole.VECTOR_STORE => await this.CreateQdrantClientAsync(cancellationToken),
+        DatabaseRole.VECTOR_STORE => await QdrantEdgeClientImplementation.CreateAsync(rustService, this.logger, this.databaseClientLogger, cancellationToken),
         _ => new NoDatabaseClient(databaseRole.ToString(), "The requested database role is not supported.")
     };
 
-    private async Task<DatabaseClient> CreateQdrantClientAsync(CancellationToken cancellationToken)
-    {
-        var qdrantInfo = await rustService.GetQdrantInfo(cancellationToken);
-        if (qdrantInfo.Status is QdrantStatus.STARTING)
-        {
-            return this.CreateNoDatabaseClient(
-                "Qdrant",
-                "Qdrant is starting. Details will appear shortly.",
-                DatabaseClientStatus.STARTING);
-        }
-
-        if (!qdrantInfo.IsAvailable || qdrantInfo.Status is QdrantStatus.UNAVAILABLE)
-        {
-            var reason = qdrantInfo.UnavailableReason ?? "unknown";
-            this.logger.LogWarning("Qdrant is not available. Starting without vector database. Reason: '{Reason}'.", reason);
-            return this.CreateNoDatabaseClient("Qdrant", qdrantInfo.UnavailableReason, DatabaseClientStatus.UNAVAILABLE);
-        }
-
-        if (!HasValidQdrantConnectionInfo(qdrantInfo, out var invalidReason))
-            return this.CreateNoDatabaseClient("Qdrant", invalidReason, DatabaseClientStatus.UNAVAILABLE);
-
-        var client = new QdrantClientImplementation("Qdrant", qdrantInfo.Path, qdrantInfo.PortHttp, qdrantInfo.PortGrpc, qdrantInfo.Fingerprint, qdrantInfo.ApiToken);
-        client.SetLogger(this.databaseClientLogger);
-
-        try
-        {
-            await client.CheckAvailabilityAsync();
-            return client;
-        }
-        catch (Exception e)
-        {
-            client.Dispose();
-            this.logger.LogWarning(e, "Qdrant reported as available by Rust, but the health check failed.");
-            return this.CreateNoDatabaseClient("Qdrant", e.Message, DatabaseClientStatus.STARTING);
-        }
-    }
-
-    private static bool HasValidQdrantConnectionInfo(QdrantInfo qdrantInfo, out string invalidReason)
-    {
-        if (qdrantInfo.Path == string.Empty)
-        {
-            invalidReason = "Failed to get the Qdrant path from Rust.";
-            return false;
-        }
-
-        if (qdrantInfo.PortHttp == 0)
-        {
-            invalidReason = "Failed to get the Qdrant HTTP port from Rust.";
-            return false;
-        }
-
-        if (qdrantInfo.PortGrpc == 0)
-        {
-            invalidReason = "Failed to get the Qdrant gRPC port from Rust.";
-            return false;
-        }
-
-        if (qdrantInfo.Fingerprint == string.Empty)
-        {
-            invalidReason = "Failed to get the Qdrant fingerprint from Rust.";
-            return false;
-        }
-
-        if (qdrantInfo.ApiToken == string.Empty)
-        {
-            invalidReason = "Failed to get the Qdrant API token from Rust.";
-            return false;
-        }
-
-        invalidReason = string.Empty;
-        return true;
-    }
-
-    private NoDatabaseClient CreateNoDatabaseClient(string name, string? unavailableReason, DatabaseClientStatus status)
-    {
-        var client = new NoDatabaseClient(name, unavailableReason, status);
-        client.SetLogger(this.databaseClientLogger);
-        return client;
-    }
-
     private static bool IsSameClient(DatabaseClient left, DatabaseClient right) =>
         left.IsAvailable
         && right.IsAvailable

app/MindWork AI Studio/Tools/Databases/Qdrant/QdrantClientImplementation.cs

@@ -1,73 +0,0 @@
-using Qdrant.Client;
-using Qdrant.Client.Grpc;
-using AIStudio.Tools.PluginSystem;
-
-namespace AIStudio.Tools.Databases.Qdrant;
-
-public class QdrantClientImplementation : DatabaseClient
-{
-    private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(QdrantClientImplementation).Namespace, nameof(QdrantClientImplementation));
-
-    private int HttpPort { get; }
-    
-    private int GrpcPort { get; }
-    
-    private QdrantClient GrpcClient { get; }
-    
-    private string Fingerprint { get; }
-    
-    private string ApiToken { get; }
-    
-    public QdrantClientImplementation(string name, string path, int httpPort, int grpcPort, string fingerprint, string apiToken): base(name, path)
-    {
-        this.HttpPort = httpPort;
-        this.GrpcPort = grpcPort;
-        this.Fingerprint = fingerprint;
-        this.ApiToken = apiToken;
-        this.GrpcClient = this.CreateQdrantClient();
-    }
-
-    public override string CacheKey => $"{this.Name}:{this.HttpPort}:{this.GrpcPort}:{this.Fingerprint}";
-    
-    private const string IP_ADDRESS = "localhost";
-
-    private QdrantClient CreateQdrantClient()
-    {
-        var address = "https://" + IP_ADDRESS + ":" + this.GrpcPort;
-        var channel = QdrantChannel.ForAddress(address, new ClientConfiguration
-        {
-            ApiKey = this.ApiToken,
-            CertificateThumbprint = this.Fingerprint
-        });
-        var grpcClient = new QdrantGrpcClient(channel);
-        return new QdrantClient(grpcClient);
-    }
-
-    private async Task<string> GetVersion()
-    {
-        var operation = await this.GrpcClient.HealthAsync();
-        return $"v{operation.Version}";
-    }
-
-    public async Task CheckAvailabilityAsync()
-    {
-        await this.GrpcClient.HealthAsync();
-    }
-
-    private async Task<string> GetCollectionsAmount()
-    {
-        var operation = await this.GrpcClient.ListCollectionsAsync();
-        return operation.Count.ToString();
-    }
-    
-    public override async IAsyncEnumerable<(string Label, string Value)> GetDisplayInfo()
-    {
-        yield return (TB("HTTP port"), this.HttpPort.ToString());
-        yield return (TB("gRPC port"), this.GrpcPort.ToString());
-        yield return (TB("Reported version"), await this.GetVersion());
-        yield return (TB("Storage size"), $"{this.GetStorageSize()}");
-        yield return (TB("Number of collections"), await this.GetCollectionsAmount());
-    }
-
-    public override void Dispose() => this.GrpcClient.Dispose();
-}

app/MindWork AI Studio/Tools/Databases/VectorStore/IVectorStoreClient.cs

@@ -0,0 +1,12 @@
+namespace AIStudio.Tools.Databases.VectorStore;
+
+public interface IVectorStoreClient
+{
+    Task EnsureVectorStoreExists(string storeName, int vectorSize, CancellationToken token);
+
+    Task InsertEmbedding(string storeName, IReadOnlyList<VectorStoragePoint> points, CancellationToken token);
+
+    Task DeleteEmbeddingByFile(string storeName, string filePath, CancellationToken token);
+
+    Task DeleteVectorStore(string storeName, CancellationToken token);
+}

app/MindWork AI Studio/Tools/Databases/VectorStore/NoVectorStoreClient.cs

@@ -0,0 +1,43 @@
+using AIStudio.Tools.PluginSystem;
+
+namespace AIStudio.Tools.Databases.VectorStore;
+
+public sealed class NoVectorStoreClient(string name, string? unavailableReason, DatabaseClientStatus status = DatabaseClientStatus.UNAVAILABLE) : DatabaseClient(name, string.Empty), IVectorStoreClient
+{
+    private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(NoVectorStoreClient).Namespace, nameof(NoVectorStoreClient));
+
+    public override DatabaseClientStatus Status => status;
+
+    public override async IAsyncEnumerable<(string Label, string Value)> GetDisplayInfo()
+    {
+        yield return (TB("Status"), status switch
+        {
+            DatabaseClientStatus.STARTING => TB("Starting"),
+            _ => TB("Unavailable")
+        });
+
+        if (!string.IsNullOrWhiteSpace(unavailableReason))
+            yield return (TB("Reason"), unavailableReason);
+
+        await Task.CompletedTask;
+    }
+
+    public Task EnsureVectorStoreExists(string storeName, int vectorSize, CancellationToken token) =>
+        Task.FromException(this.CreateUnavailableException());
+
+    public Task InsertEmbedding(string storeName, IReadOnlyList<VectorStoragePoint> points, CancellationToken token) =>
+        Task.FromException(this.CreateUnavailableException());
+
+    public Task DeleteEmbeddingByFile(string storeName, string filePath, CancellationToken token) =>
+        Task.FromException(this.CreateUnavailableException());
+
+    public Task DeleteVectorStore(string storeName, CancellationToken token) =>
+        Task.FromException(this.CreateUnavailableException());
+
+    private InvalidOperationException CreateUnavailableException() =>
+        new(unavailableReason ?? "The vector store is not available.");
+
+    public override void Dispose()
+    {
+    }
+}

app/MindWork AI Studio/Tools/Databases/VectorStore/QdrantEdgeClientImplementation.cs

@@ -0,0 +1,109 @@
+using AIStudio.Tools.PluginSystem;
+using AIStudio.Tools.Rust;
+using AIStudio.Tools.Services;
+
+namespace AIStudio.Tools.Databases.VectorStore;
+
+public sealed class QdrantEdgeClientImplementation(
+    string name,
+    string path,
+    string version,
+    int storesCount,
+    RustService rustService) : DatabaseClient(name, path), IVectorStoreClient
+{
+    private const string DATABASE_NAME = "Qdrant Edge";
+    private const string INFO_PATH = "/system/qdrant-edge/info";
+    private const string ENSURE_PATH = "/system/qdrant-edge/ensure";
+    private const string INSERT_PATH = "/system/qdrant-edge/insert";
+    private const string DELETE_FILE_PATH = "/system/qdrant-edge/delete-file";
+    private const string DELETE_STORE_PATH = "/system/qdrant-edge/delete-store";
+
+    private static string TB(string fallbackEN) => I18N.I.T(fallbackEN, typeof(QdrantEdgeClientImplementation).Namespace, nameof(QdrantEdgeClientImplementation));
+
+    public override string CacheKey => $"{this.Name}:{path}:{version}";
+
+    public static async Task<DatabaseClient> CreateAsync(
+        RustService rustService,
+        ILogger logger,
+        ILogger<DatabaseClient> databaseClientLogger,
+        CancellationToken cancellationToken)
+    {
+        var qdrantEdgeInfo = await rustService.GetDatabaseInfo(
+            DATABASE_NAME,
+            INFO_PATH,
+            QdrantEdgeInfo.Unavailable,
+            cancellationToken);
+
+        if (qdrantEdgeInfo.Status is QdrantEdgeStatus.STARTING)
+        {
+            return CreateNoVectorStoreClient(
+                DATABASE_NAME,
+                $"{DATABASE_NAME} is starting. Details will appear shortly.",
+                DatabaseClientStatus.STARTING,
+                databaseClientLogger);
+        }
+
+        if (!qdrantEdgeInfo.IsAvailable || qdrantEdgeInfo.Status is QdrantEdgeStatus.UNAVAILABLE)
+        {
+            var reason = qdrantEdgeInfo.UnavailableReason ?? "unknown";
+            logger.LogWarning("{VectorStoreName} is not available. Starting without {VectorStoreName} vector store. Reason: '{Reason}'.", DATABASE_NAME, DATABASE_NAME, reason);
+            return CreateNoVectorStoreClient(DATABASE_NAME, qdrantEdgeInfo.UnavailableReason, DatabaseClientStatus.UNAVAILABLE, databaseClientLogger);
+        }
+
+        if (qdrantEdgeInfo.Path == string.Empty)
+            return CreateNoVectorStoreClient(DATABASE_NAME, $"Failed to get the {DATABASE_NAME} path from Rust.", DatabaseClientStatus.UNAVAILABLE, databaseClientLogger);
+
+        var name = string.IsNullOrWhiteSpace(qdrantEdgeInfo.Name) ? DATABASE_NAME : qdrantEdgeInfo.Name;
+        var client = new QdrantEdgeClientImplementation(name, qdrantEdgeInfo.Path, qdrantEdgeInfo.Version, qdrantEdgeInfo.StoresCount, rustService);
+        client.SetLogger(databaseClientLogger);
+        return client;
+    }
+
+    public override async IAsyncEnumerable<(string Label, string Value)> GetDisplayInfo()
+    {
+        var currentInfo = await rustService.GetDatabaseInfo(
+            DATABASE_NAME,
+            INFO_PATH,
+            QdrantEdgeInfo.Unavailable);
+        var displayVersion = currentInfo.IsAvailable && !string.IsNullOrWhiteSpace(currentInfo.Version) ? currentInfo.Version : version;
+        var displayStoresCount = currentInfo.IsAvailable ? currentInfo.StoresCount : storesCount;
+
+        if (!currentInfo.IsAvailable)
+            yield return (TB("Status"), currentInfo.UnavailableReason ?? TB("Qdrant Edge is not available."));
+
+        yield return (TB("Reported version"), displayVersion);
+        yield return (TB("Storage size"), $"{this.GetStorageSize()}");
+        yield return (TB("Number of vector stores"), displayStoresCount.ToString());
+    }
+
+    public Task EnsureVectorStoreExists(string storeName, int vectorSize, CancellationToken token) =>
+        rustService.ExecuteDatabaseOperation(DATABASE_NAME, ENSURE_PATH, new EnsureVectorStoreRequest(storeName, vectorSize), token);
+
+    public Task InsertEmbedding(string storeName, IReadOnlyList<VectorStoragePoint> points, CancellationToken token) =>
+        rustService.ExecuteDatabaseOperation(DATABASE_NAME, INSERT_PATH, new InsertEmbeddingRequest(storeName, points), token);
+
+    public Task DeleteEmbeddingByFile(string storeName, string filePath, CancellationToken token) =>
+        rustService.ExecuteDatabaseOperation(DATABASE_NAME, DELETE_FILE_PATH, new DeleteEmbeddingByFileRequest(storeName, filePath), token);
+
+    public Task DeleteVectorStore(string storeName, CancellationToken token) =>
+        rustService.ExecuteDatabaseOperation(DATABASE_NAME, DELETE_STORE_PATH, new DeleteVectorStoreRequest(storeName), token);
+
+    public override void Dispose()
+    {
+    }
+
+    private static NoVectorStoreClient CreateNoVectorStoreClient(string name, string? unavailableReason, DatabaseClientStatus status, ILogger<DatabaseClient> databaseClientLogger)
+    {
+        var client = new NoVectorStoreClient(name, unavailableReason, status);
+        client.SetLogger(databaseClientLogger);
+        return client;
+    }
+
+    private sealed record EnsureVectorStoreRequest(string StoreName, int VectorSize);
+
+    private sealed record InsertEmbeddingRequest(string StoreName, IReadOnlyList<VectorStoragePoint> Points);
+
+    private sealed record DeleteEmbeddingByFileRequest(string StoreName, string FilePath);
+
+    private sealed record DeleteVectorStoreRequest(string StoreName);
+}

app/MindWork AI Studio/Tools/Databases/VectorStore/VectorStoragePoint.cs

@@ -0,0 +1,16 @@
+namespace AIStudio.Tools.Databases.VectorStore;
+
+public sealed record VectorStoragePoint(
+    string PointId,
+    IReadOnlyList<float> Vector,
+    string DataSourceId,
+    string DataSourceName,
+    string DataSourceType,
+    string FilePath,
+    string FileName,
+    string RelativePath,
+    int ChunkIndex,
+    string Text,
+    string Fingerprint,
+    DateTime LastWriteUtc,
+    DateTime EmbeddedAtUtc);

app/MindWork AI Studio/Tools/Metadata/MetaDataDatabasesAttribute.cs

@@ -1,6 +0,0 @@
-namespace AIStudio.Tools.Metadata;
-
-public class MetaDataDatabasesAttribute(string databaseVersion) : Attribute
-{
-    public string DatabaseVersion => databaseVersion;
-}

app/MindWork AI Studio/Tools/Metadata/MetaDataVectorStoreAttribute.cs

@@ -0,0 +1,6 @@
+namespace AIStudio.Tools.Metadata;
+
+public class MetaDataVectorStoreAttribute(string vectorStoreVersion) : Attribute
+{
+    public string VectorStoreVersion => vectorStoreVersion;
+}

app/MindWork AI Studio/Tools/Rust/QdrantEdgeInfo.cs

@@ -0,0 +1,27 @@
+namespace AIStudio.Tools.Rust;
+
+/// <summary>
+/// The response of the Qdrant Edge information request.
+/// </summary>
+public readonly record struct QdrantEdgeInfo
+{
+    public QdrantEdgeStatus Status { get; init; }
+
+    public bool IsAvailable { get; init; }
+
+    public string? UnavailableReason { get; init; }
+
+    public string Name { get; init; }
+
+    public string Version { get; init; }
+
+    public string Path { get; init; }
+
+    public int StoresCount { get; init; }
+
+    public static QdrantEdgeInfo Unavailable(string reason) => new()
+    {
+        Status = QdrantEdgeStatus.UNAVAILABLE,
+        UnavailableReason = reason
+    };
+}

app/MindWork AI Studio/Tools/Rust/QdrantEdgeStatus.cs

@@ -1,8 +1,8 @@
 namespace AIStudio.Tools.Rust;
 
-public enum QdrantStatus
+public enum QdrantEdgeStatus
 {
     STARTING,
     AVAILABLE,
     UNAVAILABLE,
-}
+}

app/MindWork AI Studio/Tools/Rust/QdrantInfo.cs

@@ -1,23 +0,0 @@
-namespace AIStudio.Tools.Rust;
-
-/// <summary>
-/// The response of the Qdrant information request.
-/// </summary>
-public readonly record struct QdrantInfo
-{
-    public QdrantStatus Status { get; init; }
-
-    public bool IsAvailable { get; init; }
-
-    public string? UnavailableReason { get; init; }
-
-    public string Path { get; init; }
-    
-    public int PortHttp { get; init; }
-    
-    public int PortGrpc { get; init; }
-    
-    public string Fingerprint { get; init; }
-    
-    public string ApiToken { get; init; }
-}

app/MindWork AI Studio/Tools/Services/RustService.Databases.cs

@@ -1,43 +1,53 @@
-using AIStudio.Tools.Rust;
-
 namespace AIStudio.Tools.Services;
 
 public sealed partial class RustService
 {
-    public async Task<QdrantInfo> GetQdrantInfo(CancellationToken cancellationToken = default)
+    public async Task<TDatabaseInfo> GetDatabaseInfo<TDatabaseInfo>(
+        string databaseName,
+        string infoPath,
+        Func<string, TDatabaseInfo> unavailableFactory,
+        CancellationToken cancellationToken = default)
     {
         try
         {
             using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
             cts.CancelAfter(TimeSpan.FromSeconds(45));
-            
-            return await this.http.GetFromJsonAsync<QdrantInfo>("/system/qdrant/info", this.jsonRustSerializerOptions, cts.Token);
+
+            var databaseInfo = await this.http.GetFromJsonAsync<TDatabaseInfo>(infoPath, this.jsonRustSerializerOptions, cts.Token);
+            return databaseInfo ?? unavailableFactory("The database information response was empty.");
         }
         catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
         {
             if(this.logger is not null)
-                this.logger.LogWarning("Fetching Qdrant info from Rust service was cancelled by caller.");
+                this.logger.LogWarning("Fetching {DatabaseName} info from Rust service was cancelled by caller.", databaseName);
             else
-                Console.WriteLine("Fetching Qdrant info from Rust service was cancelled by caller.");
-            
-            return new QdrantInfo
-            {
-                Status = QdrantStatus.UNAVAILABLE,
-                UnavailableReason = "Operation cancelled by caller."
-            };
+                Console.WriteLine($"Fetching {databaseName} info from Rust service was cancelled by caller.");
+
+            return unavailableFactory("Operation cancelled by caller.");
         }
         catch (Exception e)
         {
             if(this.logger is not null)
-                this.logger.LogError(e, "Error while fetching Qdrant info from Rust service.");
+                this.logger.LogError(e, "Error while fetching {DatabaseName} info from Rust service.", databaseName);
             else
-                Console.WriteLine($"Error while fetching Qdrant info from Rust service: '{e}'.");
-            
-            return new QdrantInfo
-            {
-                Status = QdrantStatus.UNAVAILABLE,
-                UnavailableReason = e.Message
-            };
+                Console.WriteLine($"Error while fetching {databaseName} info from Rust service: '{e}'.");
+
+            return unavailableFactory(e.Message);
         }
     }
-}
+
+    public async Task ExecuteDatabaseOperation<TRequest>(string databaseName, string path, TRequest request, CancellationToken cancellationToken = default)
+    {
+        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+        cts.CancelAfter(TimeSpan.FromMinutes(5));
+
+        using var response = await this.http.PostAsJsonAsync(path, request, this.jsonRustSerializerOptions, cts.Token);
+        response.EnsureSuccessStatusCode();
+
+        var operation = await response.Content.ReadFromJsonAsync<DatabaseOperationResponse>(this.jsonRustSerializerOptions, cts.Token);
+        if (operation is not { Success: true })
+            throw new InvalidOperationException(operation?.Issue ?? $"The {databaseName} operation failed.");
+    }
+
+    private sealed record DatabaseOperationResponse(bool Success, string Issue);
+}