diff --git a/CommunityToolkit.AI.slnx b/CommunityToolkit.AI.slnx
index 35e2b7c..a459dd0 100644
--- a/CommunityToolkit.AI.slnx
+++ b/CommunityToolkit.AI.slnx
@@ -13,6 +13,7 @@
+
@@ -32,6 +33,8 @@
+
+
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 4f15290..5684c14 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -17,6 +17,7 @@
+
@@ -46,6 +47,7 @@
+
diff --git a/MEVD/MEVD.slnf b/MEVD/MEVD.slnf
index 80d205a..ef1de46 100644
--- a/MEVD/MEVD.slnf
+++ b/MEVD/MEVD.slnf
@@ -8,6 +8,7 @@
"MEVD/src/AzureDocumentDB/AzureDocumentDB.csproj",
"MEVD/src/Chroma/Chroma.csproj",
"MEVD/src/InMemory/InMemory.csproj",
+ "MEVD/src/Milvus/Milvus.csproj",
"MEVD/src/PgVector/PgVector.csproj",
"MEVD/src/Qdrant/Qdrant.csproj",
"MEVD/src/Redis/Redis.csproj",
@@ -25,6 +26,8 @@
"MEVD/test/Chroma.ConformanceTests/Chroma.ConformanceTests.csproj",
"MEVD/test/InMemory.UnitTests/InMemory.UnitTests.csproj",
"MEVD/test/InMemory.ConformanceTests/InMemory.ConformanceTests.csproj",
+ "MEVD/test/Milvus.UnitTests/Milvus.UnitTests.csproj",
+ "MEVD/test/Milvus.ConformanceTests/Milvus.ConformanceTests.csproj",
"MEVD/test/PgVector.UnitTests/PgVector.UnitTests.csproj",
"MEVD/test/PgVector.ConformanceTests/PgVector.ConformanceTests.csproj",
"MEVD/test/Qdrant.UnitTests/Qdrant.UnitTests.csproj",
diff --git a/MEVD/src/Milvus/AssemblyInfo.cs b/MEVD/src/Milvus/AssemblyInfo.cs
new file mode 100644
index 0000000..53616c2
--- /dev/null
+++ b/MEVD/src/Milvus/AssemblyInfo.cs
@@ -0,0 +1,2 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
diff --git a/MEVD/src/Milvus/Milvus.csproj b/MEVD/src/Milvus/Milvus.csproj
new file mode 100644
index 0000000..c786b80
--- /dev/null
+++ b/MEVD/src/Milvus/Milvus.csproj
@@ -0,0 +1,31 @@
+
+
+
+ 1.0.0-preview
+ CommunityToolkit.VectorData.Milvus
+ $(AssemblyName)
+ net10.0;net8.0;netstandard2.0;net462
+
+ true
+
+ Milvus provider for Microsoft.Extensions.VectorData
+ Milvus provider for Microsoft.Extensions.VectorData by the .NET Community Toolkit
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/MEVD/src/Milvus/MilvusCollection.cs b/MEVD/src/Milvus/MilvusCollection.cs
new file mode 100644
index 0000000..e2c3bd4
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusCollection.cs
@@ -0,0 +1,597 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using Milvus.Client;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
+using Microsoft.Extensions.VectorData.ProviderServices;
+using Microsoft.Shared.Diagnostics;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// Service for storing and retrieving vector records, that uses Milvus as the underlying storage.
+///
+/// The data type of the record key. Can be , or .
+/// The data model to use for adding, updating and retrieving data from storage.
+#pragma warning disable CA1711 // Identifiers should not have incorrect suffix
+public class MilvusCollection : VectorStoreCollection, IKeywordHybridSearchable
+ where TKey : notnull
+ where TRecord : class
+#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
+{
+ /// Metadata about vector store record collection.
+ private readonly VectorStoreCollectionMetadata _collectionMetadata;
+
+ /// The default options for vector search.
+ private static readonly VectorSearchOptions s_defaultVectorSearchOptions = new();
+
+ private static readonly HybridSearchOptions s_defaultHybridSearchOptions = new();
+
+ // The two searches of a hybrid search rank at least this many records each. When they rank only the first top + skip,
+ // a record found by both can miss one of the rankings, as when records tie in the vector search, and the fusion ranks it lower.
+ private const int HybridSearchCandidates = 10;
+
+ // The most records a Milvus search ranks.
+ private const int MaxSearchLimit = 16384;
+
+ // How long EnsureCollectionExistsAsync waits for the collection to load: a little longer than the load timeout of the
+ // server, 600 seconds in the default configuration of Milvus 2.6.25 (queryCoord.loadTimeoutSeconds), so that the
+ // provider does not give up on a load sooner than the server; a load that never ends still stops.
+ internal TimeSpan LoadTimeout { get; set; } = TimeSpan.FromMinutes(11);
+
+ /// The name of the upsert operation for telemetry purposes.
+ private const string UpsertName = "Upsert";
+
+ /// The name of the Delete operation for telemetry purposes.
+ private const string DeleteName = "Delete";
+
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ private readonly SharedMilvusClient _milvusClient;
+
+ /// Milvus client of the records of the collection.
+ private readonly global::Milvus.Client.MilvusCollection _records;
+
+ /// The model for this collection.
+ private readonly CollectionModel _model;
+
+ /// A mapper to use for converting between Milvus records and consumer models.
+ private readonly MilvusMapper _mapper;
+
+ /// Whether the collection was disposed: it releases its share of the client only once.
+ private int _disposed;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ /// The name of the collection that this will access.
+ /// A value indicating whether is disposed when the collection is disposed.
+ /// Optional configuration options for this class.
+ /// Thrown if the is null.
+ /// Thrown for any misconfigured options.
+ [RequiresDynamicCode("This constructor is incompatible with NativeAOT. For dynamic mapping via Dictionary, instantiate MilvusDynamicCollection instead.")]
+ [RequiresUnreferencedCode("This constructor is incompatible with trimming. For dynamic mapping via Dictionary, instantiate MilvusDynamicCollection instead")]
+ public MilvusCollection(MilvusClient milvusClient, string name, bool ownsClient, MilvusCollectionOptions? options = null)
+ : this(() => new SharedMilvusClient(milvusClient, ownsClient), name, options)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client factory.
+ /// The name of the collection that this will access.
+ /// Optional configuration options for this class.
+ /// Thrown if the is null.
+ /// Thrown for any misconfigured options.
+ [RequiresDynamicCode("This constructor is incompatible with NativeAOT. For dynamic mapping via Dictionary, instantiate MilvusDynamicCollection instead.")]
+ [RequiresUnreferencedCode("This constructor is incompatible with trimming. For dynamic mapping via Dictionary, instantiate MilvusDynamicCollection instead")]
+ internal MilvusCollection(Func clientFactory, string name, MilvusCollectionOptions? options = null)
+ : this(
+ clientFactory,
+ name,
+ static options => typeof(TRecord) == typeof(Dictionary)
+ ? throw new NotSupportedException(VectorDataStrings.NonDynamicCollectionWithDictionaryNotSupported(typeof(MilvusDynamicCollection)))
+ : new MilvusModelBuilder().Build(typeof(TRecord), typeof(TKey), options.Definition, options.EmbeddingGenerator),
+ options)
+ {
+ }
+
+ internal MilvusCollection(Func clientFactory, string name, Func modelFactory, MilvusCollectionOptions? options)
+ {
+ // Verify.
+ Throw.IfNull(clientFactory);
+
+ // The collection holds the client from here: when the rest of the construction throws, it releases the client,
+ // so that a client it was to own is disposed, and a client it shares with its vector store is given back.
+ _milvusClient = clientFactory();
+ try
+ {
+ Throw.IfNullOrWhitespace(name);
+
+ if (typeof(TKey) != typeof(long) && typeof(TKey) != typeof(string) && typeof(TKey) != typeof(Guid) && typeof(TKey) != typeof(object))
+ {
+ throw new NotSupportedException("Only long, string and Guid keys are supported.");
+ }
+
+ options ??= MilvusCollectionOptions.Default;
+
+ // Assign.
+ Name = name;
+ _model = modelFactory(options);
+ _mapper = new MilvusMapper(_model);
+ }
+ catch
+ {
+ _milvusClient.Dispose();
+ throw;
+ }
+
+ _records = _milvusClient.Client.GetCollection(name);
+
+ _collectionMetadata = new()
+ {
+ VectorStoreSystemName = MilvusConstants.VectorStoreSystemName,
+ VectorStoreName = _milvusClient.DatabaseName,
+ CollectionName = name
+ };
+ }
+
+ ///
+ protected override void Dispose(bool disposing)
+ {
+ if (Interlocked.Exchange(ref _disposed, 1) == 0)
+ {
+ _milvusClient.Dispose();
+ }
+
+ base.Dispose(disposing);
+ }
+
+ ///
+ public override string Name { get; }
+
+ ///
+ public override Task CollectionExistsAsync(CancellationToken cancellationToken = default)
+ => RunOperationAsync("CollectionExists", () => _milvusClient.Client.HasCollectionAsync(Name, cancellationToken: cancellationToken));
+
+ ///
+ public override Task EnsureCollectionExistsAsync(CancellationToken cancellationToken = default)
+ => RunOperationAsync("EnsureCollectionExists", async () =>
+ {
+ // The indexes are created with the collection. Those of an existing collection stay as they are: Milvus rejects
+ // an index with other settings on an indexed field, or on a field the collection does not have.
+ if (!await _milvusClient.Client.HasCollectionAsync(Name, cancellationToken: cancellationToken).ConfigureAwait(false))
+ {
+ await _milvusClient.Client.CreateCollectionAsync(Name, MilvusCollectionCreateMapping.MapCollectionSchema(_model),
+ cancellationToken: cancellationToken).ConfigureAwait(false);
+ foreach (var vector in _model.VectorProperties)
+ {
+ var indexType = MilvusCollectionCreateMapping.GetIndexType(vector);
+ var parameters = indexType == IndexType.Hnsw
+ ? new Dictionary { ["M"] = "16", ["efConstruction"] = "200" } : null;
+ await _records.CreateIndexAsync(vector.StorageName, indexType,
+ MilvusCollectionCreateMapping.GetMetric(vector), extraParams: parameters,
+ cancellationToken: cancellationToken).ConfigureAwait(false);
+ }
+ foreach (var property in MilvusCollectionCreateMapping.GetFullTextProperties(_model))
+ {
+ await _records.CreateIndexAsync(MilvusCollectionCreateMapping.GetBm25FieldName(property), IndexType.SparseInvertedIndex,
+ SimilarityMetricType.Bm25, cancellationToken: cancellationToken).ConfigureAwait(false);
+ }
+ }
+ await _records.LoadAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+ await _records.WaitForCollectionLoadAsync(timeout: LoadTimeout, cancellationToken: cancellationToken).ConfigureAwait(false);
+ });
+
+ ///
+ public override Task EnsureCollectionDeletedAsync(CancellationToken cancellationToken = default)
+ => RunOperationAsync("DeleteCollection", async () =>
+ {
+ if (await _milvusClient.Client.HasCollectionAsync(Name, cancellationToken: cancellationToken).ConfigureAwait(false))
+ {
+ await _records.DropAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
+ }
+ });
+
+ ///
+ public override async Task GetAsync(TKey key, RecordRetrievalOptions? options = null, CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(key);
+
+ var records = await GetAsync([key], options, cancellationToken).ToListAsync(cancellationToken).ConfigureAwait(false);
+ return records.FirstOrDefault();
+ }
+
+ ///
+ public override async IAsyncEnumerable GetAsync(
+ IEnumerable keys,
+ RecordRetrievalOptions? options = default,
+ [EnumeratorCancellation] CancellationToken cancellationToken = default)
+ {
+ const string OperationName = "Get";
+
+ Throw.IfNull(keys);
+
+ var includeVectors = options?.IncludeVectors ?? false;
+ if (includeVectors && _model.EmbeddingGenerationRequired)
+ {
+ throw new NotSupportedException(VectorDataStrings.IncludeVectorsNotSupportedWithEmbeddingGeneration);
+ }
+
+ var keyList = keys.ToList();
+ if (keyList.Count == 0)
+ {
+ yield break;
+ }
+ var parameters = CreateQueryParameters(includeVectors);
+ var entries = await RunOperationAsync(OperationName,
+ () => _records.QueryRowsAsync(KeyFilter(keyList), parameters, cancellationToken)).ConfigureAwait(false);
+ foreach (var entry in entries)
+ {
+ yield return _mapper.MapFromStorageToDataModel(entry, includeVectors);
+ }
+ }
+
+ ///
+ public override Task DeleteAsync(TKey key, CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(key);
+
+ return DeleteAsync([key], cancellationToken);
+ }
+
+ ///
+ public override Task DeleteAsync(IEnumerable keys, CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(keys);
+
+ var keyList = keys.ToList();
+ return keyList.Count == 0 ? Task.CompletedTask
+ : RunOperationAsync(DeleteName, () => _records.DeleteAsync(KeyFilter(keyList), cancellationToken: cancellationToken));
+ }
+
+ ///
+ public override async Task UpsertAsync(TRecord record, CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(record);
+
+ await UpsertAsync([record], cancellationToken).ConfigureAwait(false);
+ }
+
+ ///
+ public override async Task UpsertAsync(IEnumerable records, CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(records);
+
+ IReadOnlyList? recordsList = null;
+
+ // If an embedding generator is defined, invoke it once per property for all records.
+ GeneratedEmbeddings>?[]? generatedEmbeddings = null;
+
+ var vectorPropertyCount = _model.VectorProperties.Count;
+ for (var i = 0; i < vectorPropertyCount; i++)
+ {
+ var vectorProperty = _model.VectorProperties[i];
+
+ if (MilvusModelBuilder.IsVectorPropertyTypeValidCore(vectorProperty.Type, out _))
+ {
+ continue;
+ }
+
+ // We have a vector property whose type isn't natively supported - we need to generate embeddings.
+ Debug.Assert(vectorProperty.EmbeddingGenerator is not null);
+
+ if (recordsList is null)
+ {
+ recordsList = records is IReadOnlyList r ? r : records.ToList();
+
+ if (recordsList.Count == 0)
+ {
+ return;
+ }
+
+ records = recordsList;
+ }
+
+ // TODO: Ideally we'd group together vector properties using the same generator (and with the same input and output properties),
+ // and generate embeddings for them in a single batch. That's some more complexity though.
+ generatedEmbeddings ??= new GeneratedEmbeddings>?[vectorPropertyCount];
+ generatedEmbeddings[i] = (GeneratedEmbeddings>)await vectorProperty.GenerateEmbeddingsAsync(records.Select(r => vectorProperty.GetValueAsObject(r)), cancellationToken).ConfigureAwait(false);
+ }
+
+ var keyProperty = _model.KeyProperty;
+ var rows = new List>();
+ var index = 0;
+ foreach (var record in records)
+ {
+ Throw.IfNull(record);
+ if (keyProperty.IsAutoGenerated && keyProperty.GetValue(record) == Guid.Empty)
+ {
+ keyProperty.SetValue(record, Guid.NewGuid());
+ }
+ rows.Add(_mapper.MapFromDataToStorageModel(record, index++, generatedEmbeddings));
+ }
+ if (rows.Count > 0)
+ {
+ await RunOperationAsync(UpsertName, () => _records.UpsertAsync(MilvusFieldMapping.CreateColumns(_model, rows), cancellationToken: cancellationToken)).ConfigureAwait(false);
+ }
+ }
+
+ #region Search
+
+ ///
+ public override async IAsyncEnumerable> SearchAsync(
+ TInput searchValue,
+ int top,
+ VectorSearchOptions? options = null,
+ [EnumeratorCancellation] CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(searchValue);
+ Throw.IfLessThan(top, 1);
+
+ options ??= s_defaultVectorSearchOptions;
+ if (options.IncludeVectors && _model.EmbeddingGenerationRequired)
+ {
+ throw new NotSupportedException(VectorDataStrings.IncludeVectorsNotSupportedWithEmbeddingGeneration);
+ }
+
+ var vectorProperty = _model.GetVectorPropertyOrSingle(options);
+
+ var vector = await GetSearchVectorAsync(searchValue, vectorProperty, cancellationToken).ConfigureAwait(false);
+ if (vector.Length != vectorProperty.Dimensions)
+ {
+ throw new ArgumentException($"Search vector must have {vectorProperty.Dimensions} dimensions.", nameof(searchValue));
+ }
+ var parameters = new SearchParameters
+ {
+ Offset = options.Skip,
+ Expression = options.Filter is null ? null : new MilvusFilterTranslator().Translate(options.Filter, _model),
+ ConsistencyLevel = ConsistencyLevel.Strong,
+ };
+ foreach (var field in GetOutputFields(options.IncludeVectors))
+ {
+ parameters.OutputFields.Add(field);
+ }
+ if (MilvusCollectionCreateMapping.GetIndexType(vectorProperty) == IndexType.Hnsw)
+ {
+ parameters.ExtraParameters["ef"] = Math.Max(64, top + options.Skip).ToString(System.Globalization.CultureInfo.InvariantCulture);
+ }
+ var results = await RunOperationAsync("Search", () => SearchAllowingEmptyResultsAsync(
+ () => _records.SearchAsync(vectorProperty.StorageName, [vector],
+ MilvusCollectionCreateMapping.GetMetric(vectorProperty), top, parameters, cancellationToken),
+ parameters.OutputFields)).ConfigureAwait(false);
+ if (IsEmpty(results))
+ {
+ yield break;
+ }
+ foreach (var hit in results.GetHits())
+ {
+ var score = MilvusCollectionSearchMapping.MapScore(hit.Score, vectorProperty.DistanceFunction);
+ if (MilvusCollectionSearchMapping.PassesThreshold(score, options.ScoreThreshold, vectorProperty.DistanceFunction))
+ {
+ yield return new VectorSearchResult(MapHit(hit, options.IncludeVectors), score);
+ }
+ }
+ }
+
+ ///
+ public async IAsyncEnumerable> HybridSearchAsync(
+ TInput searchValue,
+ ICollection keywords,
+ int top,
+ HybridSearchOptions? options = null,
+ [EnumeratorCancellation] CancellationToken cancellationToken = default)
+ where TInput : notnull
+ {
+ Throw.IfNull(searchValue);
+ Throw.IfNull(keywords);
+ Throw.IfLessThan(top, 1);
+
+ options ??= s_defaultHybridSearchOptions;
+ if ((long)top + options.Skip > MaxSearchLimit)
+ {
+ throw new ArgumentOutOfRangeException(nameof(top),
+ $"Milvus hybrid search ranks at most {MaxSearchLimit} records, the skipped ones included: top + Skip is {(long)top + options.Skip}.");
+ }
+ if (options.IncludeVectors && _model.EmbeddingGenerationRequired)
+ {
+ throw new NotSupportedException(VectorDataStrings.IncludeVectorsNotSupportedWithEmbeddingGeneration);
+ }
+
+ var vectorProperty = _model.GetVectorPropertyOrSingle(new() { VectorProperty = options.VectorProperty });
+ var textProperty = _model.GetFullTextDataPropertyOrSingle(options.AdditionalProperty);
+ var filter = options.Filter is null ? null : new MilvusFilterTranslator().Translate(options.Filter, _model);
+
+ var vector = await GetSearchVectorAsync(searchValue, vectorProperty, cancellationToken).ConfigureAwait(false);
+ if (vector.Length != vectorProperty.Dimensions)
+ {
+ throw new ArgumentException($"Search vector must have {vectorProperty.Dimensions} dimensions.", nameof(searchValue));
+ }
+
+ // A vector search and a BM25 search of the keywords, both filtered, fused with Reciprocal Rank Fusion.
+ // Milvus has no offset for hybrid search: the skipped records are asked for too, and dropped.
+ var limit = top + options.Skip;
+ var candidates = Math.Max(limit, HybridSearchCandidates);
+ var vectorSearch = new VectorAnnSearchRequest(vectorProperty.StorageName, [vector],
+ MilvusCollectionCreateMapping.GetMetric(vectorProperty), candidates)
+ {
+ Expression = filter,
+ };
+ if (MilvusCollectionCreateMapping.GetIndexType(vectorProperty) == IndexType.Hnsw)
+ {
+ vectorSearch.ExtraParameters["ef"] = Math.Max(64, candidates).ToString(System.Globalization.CultureInfo.InvariantCulture);
+ }
+ var keywordSearch = new TextAnnSearchRequest(MilvusCollectionCreateMapping.GetBm25FieldName(textProperty),
+ [string.Join(" ", keywords)], candidates)
+ {
+ Expression = filter,
+ };
+ var parameters = new HybridSearchParameters { ConsistencyLevel = ConsistencyLevel.Strong };
+ foreach (var field in GetOutputFields(options.IncludeVectors))
+ {
+ parameters.OutputFields.Add(field);
+ }
+ var results = await RunOperationAsync("HybridSearch", () => SearchAllowingEmptyResultsAsync(
+ () => _records.HybridSearchAsync([vectorSearch, keywordSearch], new RrfReranker(60), limit, parameters, cancellationToken),
+ parameters.OutputFields)).ConfigureAwait(false);
+ if (IsEmpty(results))
+ {
+ yield break;
+ }
+ foreach (var hit in results.GetHits().Skip(options.Skip))
+ {
+ // A higher RRF score ranks higher: the threshold is a lower bound.
+ if (options.ScoreThreshold is not { } threshold || hit.Score >= threshold)
+ {
+ yield return new VectorSearchResult(MapHit(hit, options.IncludeVectors), hit.Score);
+ }
+ }
+ }
+
+ // Milvus.Client 2.6.0 cannot decode untyped output fields in an empty response.
+ // Retry without output fields to verify that this really is an empty search;
+ // do not hide the SDK error if the retry finds any records.
+ private static async Task SearchAllowingEmptyResultsAsync(Func> search, IList outputFields)
+ {
+ try
+ {
+ return await search().ConfigureAwait(false);
+ }
+ catch (NotSupportedException exception) when (exception.Message == "Cannot convert None FieldData to Field")
+ {
+ outputFields.Clear();
+ var retry = await search().ConfigureAwait(false);
+ if (!IsEmpty(retry))
+ {
+ throw;
+ }
+ return retry;
+ }
+ }
+
+ private static bool IsEmpty(SearchResults results) => (results.Ids.LongIds?.Count ?? results.Ids.StringIds?.Count ?? 0) == 0;
+
+ private TRecord MapHit(SearchHit hit, bool includeVectors)
+ {
+ var row = hit.Fields.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.Ordinal);
+ row[_model.KeyProperty.StorageName] = hit.Id;
+ return _mapper.MapFromStorageToDataModel(row, includeVectors);
+ }
+
+ private static async ValueTask> GetSearchVectorAsync(TInput searchValue, VectorPropertyModel vectorProperty, CancellationToken cancellationToken)
+ where TInput : notnull
+ => searchValue switch
+ {
+ float[] array => array,
+ ReadOnlyMemory r => r,
+ Embedding e => e.Vector,
+ _ when vectorProperty.EmbeddingGenerationDispatcher is not null
+ => ((Embedding)await vectorProperty.GenerateEmbeddingAsync(searchValue, cancellationToken).ConfigureAwait(false)).Vector,
+
+ _ => vectorProperty.EmbeddingGenerator is null
+ ? throw new NotSupportedException(VectorDataStrings.InvalidSearchInputAndNoEmbeddingGeneratorWasConfigured(searchValue.GetType(), MilvusModelBuilder.SupportedVectorTypes))
+ : throw new InvalidOperationException(VectorDataStrings.IncompatibleEmbeddingGeneratorWasConfiguredForInputType(typeof(TInput), vectorProperty.EmbeddingGenerator.GetType()))
+ };
+
+ #endregion Search
+
+ ///
+ public override async IAsyncEnumerable GetAsync(Expression> filter, int top,
+ FilteredRecordRetrievalOptions? options = null, [EnumeratorCancellation] CancellationToken cancellationToken = default)
+ {
+ Throw.IfNull(filter);
+ Throw.IfLessThan(top, 1);
+
+ options ??= new();
+
+ if (options.IncludeVectors && _model.EmbeddingGenerationRequired)
+ {
+ throw new NotSupportedException(VectorDataStrings.IncludeVectorsNotSupportedWithEmbeddingGeneration);
+ }
+
+ if (options.OrderBy?.Invoke(new()).Values is { Count: > 0 })
+ {
+ throw new NotSupportedException("Milvus does not support ordering.");
+ }
+
+ var milvusFilter = new MilvusFilterTranslator().Translate(filter, _model);
+ var parameters = CreateQueryParameters(options.IncludeVectors);
+ parameters.Limit = top;
+ parameters.Offset = options.Skip;
+ var entries = await RunOperationAsync("Get",
+ () => _records.QueryRowsAsync(milvusFilter, parameters, cancellationToken)).ConfigureAwait(false);
+ foreach (var entry in entries)
+ {
+ yield return _mapper.MapFromStorageToDataModel(entry, options.IncludeVectors);
+ }
+ }
+
+ ///
+ public override object? GetService(Type serviceType, object? serviceKey = null)
+ {
+ Throw.IfNull(serviceType);
+
+ return
+ serviceKey is not null ? null :
+ serviceType == typeof(VectorStoreCollectionMetadata) ? _collectionMetadata :
+ serviceType == typeof(MilvusClient) ? _milvusClient.Client :
+ // Hybrid search needs a full-text indexed property.
+ serviceType == typeof(IKeywordHybridSearchable) ? (MilvusCollectionCreateMapping.GetFullTextProperties(_model).Any() ? this : null) :
+ serviceType.IsInstanceOfType(this) ? this :
+ null;
+ }
+
+ private string KeyFilter(IEnumerable keys)
+ {
+ var literals = keys.Select(key =>
+ {
+ Throw.IfNull(key);
+ if (key.GetType() != _model.KeyProperty.Type)
+ {
+ throw new ArgumentException($"Expected key type '{_model.KeyProperty.Type}'.", nameof(keys));
+ }
+ return MilvusFieldMapping.Literal(key);
+ });
+ return $"{_model.KeyProperty.StorageName} in [{string.Join(", ", literals)}]";
+ }
+
+ private IEnumerable GetOutputFields(bool includeVectors)
+ => new[] { _model.KeyProperty.StorageName }.Concat(_model.DataProperties.Select(p => p.StorageName))
+ .Concat(includeVectors ? _model.VectorProperties.Select(p => p.StorageName) : []);
+
+ private QueryParameters CreateQueryParameters(bool includeVectors)
+ {
+ var parameters = new QueryParameters { ConsistencyLevel = ConsistencyLevel.Strong };
+ foreach (var field in GetOutputFields(includeVectors))
+ {
+ parameters.OutputFields.Add(field);
+ }
+ return parameters;
+ }
+
+ ///
+ /// Run the given operation and wrap any with .
+ ///
+ /// The type of database operation being run.
+ /// The operation to run.
+ /// The result of the operation.
+ private Task RunOperationAsync(string operationName, Func operation)
+ => MilvusErrorHandler.RunAsync(_collectionMetadata, operationName, operation);
+
+ ///
+ /// Run the given operation and wrap any with .
+ ///
+ /// The response type of the operation.
+ /// The type of database operation being run.
+ /// The operation to run.
+ /// The result of the operation.
+ // Awaited here rather than returned: otherwise the NativeAOT compiler of .NET 10 fails on the state machine of the handler (dotnet/runtime#120847).
+ private async Task RunOperationAsync(string operationName, Func> operation)
+ => await MilvusErrorHandler.RunAsync(_collectionMetadata, operationName, operation).ConfigureAwait(false);
+}
diff --git a/MEVD/src/Milvus/MilvusCollectionCreateMapping.cs b/MEVD/src/Milvus/MilvusCollectionCreateMapping.cs
new file mode 100644
index 0000000..2c3ed98
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusCollectionCreateMapping.cs
@@ -0,0 +1,93 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.Client;
+using Microsoft.Extensions.VectorData;
+using Microsoft.Extensions.VectorData.ProviderServices;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal static class MilvusCollectionCreateMapping
+{
+ public static IReadOnlyList MapCollectionDefinition(CollectionModel model)
+ {
+ var key = model.KeyProperty;
+ List fields = [key.Type == typeof(long)
+ ? FieldSchema.Create(key.StorageName, isPrimaryKey: true)
+ : FieldSchema.CreateVarchar(key.StorageName, 65535, isPrimaryKey: true)];
+ foreach (var property in model.DataProperties)
+ {
+ var type = Nullable.GetUnderlyingType(property.Type) ?? property.Type;
+ var nullable = !property.Type.IsValueType || Nullable.GetUnderlyingType(property.Type) is not null;
+ if (MilvusFieldMapping.GetElementType(type) is { } element)
+ {
+ var name = property.StorageName;
+ var field = element == typeof(string) ? FieldSchema.CreateVarcharArray(name, 4096, 65535, nullable: true)
+ : element == typeof(bool) ? FieldSchema.CreateArray(name, 4096, nullable: true)
+ : element == typeof(int) ? FieldSchema.CreateArray(name, 4096, nullable: true)
+ : element == typeof(long) ? FieldSchema.CreateArray(name, 4096, nullable: true)
+ : element == typeof(float) ? FieldSchema.CreateArray(name, 4096, nullable: true)
+ : element == typeof(double) ? FieldSchema.CreateArray(name, 4096, nullable: true)
+ : throw new NotSupportedException($"Unsupported Milvus array element type '{element}'.");
+ fields.Add(field);
+ continue;
+ }
+ fields.Add(type == typeof(string)
+ ? FieldSchema.CreateVarchar(property.StorageName, 65535, nullable: true, enableAnalyzer: property.IsFullTextIndexed)
+ : FieldSchema.Create(property.StorageName, MilvusFieldMapping.GetDataType(type), nullable: nullable));
+ }
+ foreach (var vector in model.VectorProperties)
+ {
+ fields.Add(FieldSchema.CreateFloatVector(vector.StorageName, vector.Dimensions));
+ }
+ foreach (var property in GetFullTextProperties(model))
+ {
+ fields.Add(FieldSchema.CreateSparseFloatVector(GetBm25FieldName(property)));
+ }
+ return fields;
+ }
+
+ ///
+ /// Maps the model to the schema of the collection: its fields, and for each full-text indexed property, a BM25
+ /// function that Milvus runs on the text to fill the hidden BM25 field.
+ ///
+ public static CollectionSchema MapCollectionSchema(CollectionModel model)
+ {
+ var schema = new CollectionSchema();
+ foreach (var field in MapCollectionDefinition(model))
+ {
+ schema.Fields.Add(field);
+ }
+ foreach (var property in GetFullTextProperties(model))
+ {
+ var bm25FieldName = GetBm25FieldName(property);
+ schema.Functions.Add(FunctionSchema.CreateBm25(bm25FieldName, property.StorageName, bm25FieldName));
+ }
+ return schema;
+ }
+
+ public static IEnumerable GetFullTextProperties(CollectionModel model)
+ => model.DataProperties.Where(p => p.IsFullTextIndexed);
+
+ ///
+ /// Gets the name of the hidden sparse field that holds the BM25 vectors of a full-text indexed property, and of
+ /// the BM25 function that fills it: the storage name of the property with _bm25.
+ ///
+ public static string GetBm25FieldName(DataPropertyModel property) => property.StorageName + "_bm25";
+
+ public static SimilarityMetricType GetMetric(VectorPropertyModel property) => property.DistanceFunction switch
+ {
+ null or DistanceFunction.CosineSimilarity => SimilarityMetricType.Cosine,
+ DistanceFunction.DotProductSimilarity => SimilarityMetricType.Ip,
+ DistanceFunction.EuclideanSquaredDistance or DistanceFunction.EuclideanDistance => SimilarityMetricType.L2,
+ _ => throw new NotSupportedException($"Milvus does not support distance function '{property.DistanceFunction}'."),
+ };
+
+ public static IndexType GetIndexType(VectorPropertyModel property) => property.IndexKind switch
+ {
+ null => IndexType.AutoIndex,
+ IndexKind.Flat => IndexType.Flat,
+ IndexKind.Hnsw => IndexType.Hnsw,
+ _ => throw new NotSupportedException($"Milvus does not support index kind '{property.IndexKind}'."),
+ };
+}
diff --git a/MEVD/src/Milvus/MilvusCollectionOptions.cs b/MEVD/src/Milvus/MilvusCollectionOptions.cs
new file mode 100644
index 0000000..1a05351
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusCollectionOptions.cs
@@ -0,0 +1,25 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.VectorData;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// Options when creating a .
+///
+public sealed class MilvusCollectionOptions : VectorStoreCollectionOptions
+{
+ internal static readonly MilvusCollectionOptions Default = new();
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public MilvusCollectionOptions()
+ {
+ }
+
+ internal MilvusCollectionOptions(MilvusCollectionOptions? source) : base(source)
+ {
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusCollectionSearchMapping.cs b/MEVD/src/Milvus/MilvusCollectionSearchMapping.cs
new file mode 100644
index 0000000..12d98b8
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusCollectionSearchMapping.cs
@@ -0,0 +1,17 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.VectorData;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal static class MilvusCollectionSearchMapping
+{
+ // For L2, Milvus returns the squared Euclidean distance: the Euclidean distance is its square root.
+ public static double MapScore(float score, string? distanceFunction)
+ => distanceFunction == DistanceFunction.EuclideanDistance ? Math.Sqrt(score) : score;
+
+ public static bool PassesThreshold(double score, double? threshold, string? distanceFunction)
+ => threshold is null || (distanceFunction is DistanceFunction.EuclideanSquaredDistance or DistanceFunction.EuclideanDistance
+ ? score <= threshold.Value : score >= threshold.Value);
+}
diff --git a/MEVD/src/Milvus/MilvusConstants.cs b/MEVD/src/Milvus/MilvusConstants.cs
new file mode 100644
index 0000000..877ea52
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusConstants.cs
@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal static class MilvusConstants
+{
+ internal const string VectorStoreSystemName = "milvus";
+}
diff --git a/MEVD/src/Milvus/MilvusDynamicCollection.cs b/MEVD/src/Milvus/MilvusDynamicCollection.cs
new file mode 100644
index 0000000..70be65a
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusDynamicCollection.cs
@@ -0,0 +1,38 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.Client;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// Represents a collection of vector store records in a Milvus database, mapped to a dynamic Dictionary<string, object?>.
+///
+#pragma warning disable CA1711 // Identifiers should not have incorrect suffix
+public sealed class MilvusDynamicCollection : MilvusCollection>
+#pragma warning restore CA1711 // Identifiers should not have incorrect suffix
+{
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client that can be used to manage the collections and points in a Milvus store.
+ /// The name of the collection.
+ /// A value indicating whether is disposed when the collection is disposed.
+ /// Optional configuration options for this class.
+ public MilvusDynamicCollection(MilvusClient milvusClient, string name, bool ownsClient, MilvusCollectionOptions options)
+ : this(() => new SharedMilvusClient(milvusClient, ownsClient), name, options)
+ {
+ }
+
+ internal MilvusDynamicCollection(Func clientFactory, string name, MilvusCollectionOptions options)
+ : base(
+ clientFactory,
+ name,
+ static options => new MilvusModelBuilder()
+ .BuildDynamic(
+ options.Definition ?? throw new ArgumentException("Definition is required for dynamic collections"),
+ options.EmbeddingGenerator),
+ options)
+ {
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusErrorHandler.cs b/MEVD/src/Milvus/MilvusErrorHandler.cs
new file mode 100644
index 0000000..970e933
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusErrorHandler.cs
@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Grpc.Core;
+using Microsoft.Extensions.VectorData;
+using Milvus.Client;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+// Milvus.Client reports server errors as MilvusException, gRPC errors as RpcException, and a wait that runs out of time,
+// such as the wait for a collection to load, as TimeoutException.
+internal static class MilvusErrorHandler
+{
+ public static Task RunAsync(VectorStoreCollectionMetadata metadata, string operationName, Func operation)
+ => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName,
+ () => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName,
+ () => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName, operation)));
+
+ public static Task RunAsync(VectorStoreCollectionMetadata metadata, string operationName, Func> operation)
+ => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName,
+ () => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName,
+ () => VectorStoreErrorHandler.RunOperationAsync(metadata, operationName, operation)));
+}
diff --git a/MEVD/src/Milvus/MilvusFieldMapping.cs b/MEVD/src/Milvus/MilvusFieldMapping.cs
new file mode 100644
index 0000000..257ca83
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusFieldMapping.cs
@@ -0,0 +1,129 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Globalization;
+using System.Text;
+using Milvus.Client;
+using Microsoft.Extensions.VectorData.ProviderServices;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal static class MilvusFieldMapping
+{
+ public static MilvusDataType GetDataType(Type type)
+ => type == typeof(string) ? MilvusDataType.VarChar
+ : type == typeof(bool) ? MilvusDataType.Bool
+ : type == typeof(int) ? MilvusDataType.Int32
+ : type == typeof(long) ? MilvusDataType.Int64
+ : type == typeof(float) ? MilvusDataType.Float
+ : type == typeof(double) ? MilvusDataType.Double
+ : throw new NotSupportedException($"Unsupported Milvus field type '{type}'.");
+
+ internal static Type? GetElementType(Type type)
+ => type.IsArray ? type.GetElementType()
+ : type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>) ? type.GenericTypeArguments[0] : null;
+
+ internal static object? ReadValue(object? value, Type type)
+ {
+ if (value is null || GetElementType(type) is not { } element)
+ {
+ return value;
+ }
+ return element == typeof(string) ? ReadArray(value, type.IsArray)
+ : element == typeof(bool) ? ReadArray(value, type.IsArray)
+ : element == typeof(int) ? ReadArray(value, type.IsArray)
+ : element == typeof(long) ? ReadArray(value, type.IsArray)
+ : element == typeof(float) ? ReadArray(value, type.IsArray)
+ : element == typeof(double) ? ReadArray(value, type.IsArray)
+ : throw new NotSupportedException($"Unsupported array element type '{element}'.");
+
+ static object ReadArray(object value, bool array)
+ => array ? ((IEnumerable)value).ToArray() : ((IEnumerable)value).ToList();
+ }
+
+ internal static IReadOnlyList CreateColumns(CollectionModel model, IReadOnlyList> rows)
+ {
+ List fields = [];
+ var key = model.KeyProperty;
+ fields.Add(key.Type == typeof(long) ? Scalar(key.StorageName) : Scalar(key.StorageName));
+ foreach (var property in model.DataProperties)
+ {
+ var name = property.StorageName;
+ if (GetElementType(property.Type) is { } element)
+ {
+ fields.Add(element == typeof(string) ? ArrayColumn(name)
+ : element == typeof(bool) ? ArrayColumn(name)
+ : element == typeof(int) ? ArrayColumn(name)
+ : element == typeof(long) ? ArrayColumn(name)
+ : element == typeof(float) ? ArrayColumn(name)
+ : element == typeof(double) ? ArrayColumn(name)
+ : throw new NotSupportedException($"Unsupported array element type '{element}'."));
+ }
+ else
+ {
+ var type = property.Type;
+ fields.Add(type == typeof(string) ? Scalar(name)
+ : type == typeof(bool) ? Scalar(name) : type == typeof(bool?) ? Scalar(name)
+ : type == typeof(int) ? Scalar(name) : type == typeof(int?) ? Scalar(name)
+ : type == typeof(long) ? Scalar(name) : type == typeof(long?) ? Scalar(name)
+ : type == typeof(float) ? Scalar(name) : type == typeof(float?) ? Scalar(name)
+ : type == typeof(double) ? Scalar(name) : type == typeof(double?) ? Scalar(name)
+ : throw new NotSupportedException($"Unsupported Milvus data type '{type}'."));
+ }
+ }
+ foreach (var property in model.VectorProperties)
+ {
+ fields.Add(FieldData.CreateFloatVector(property.StorageName, rows.Select(r => (ReadOnlyMemory)r[property.StorageName]!).ToArray()));
+ }
+ return fields;
+
+ FieldData Scalar(string name) => FieldData.Create(name, rows.Select(r => (T)r[name]!).ToArray());
+ FieldData ArrayColumn(string name) => FieldData.CreateArray(name,
+ rows.Select(r => r[name] is { } value ? (IReadOnlyList)((IEnumerable)value).ToArray() : null).ToArray());
+ }
+
+ public static object ToKey(object key) => key is Guid guid ? guid.ToString("D") : key;
+
+ // Milvus parses backslash escapes, but does not combine JSON surrogate-pair escapes.
+ // Keep Unicode code units intact so non-BMP characters reach the server as UTF-8.
+ internal static string EscapeString(string value)
+ {
+ var builder = new StringBuilder(value.Length + 2).Append('"');
+ foreach (var c in value)
+ {
+ switch (c)
+ {
+ case '"': builder.Append("\\\""); break;
+ case '\\': builder.Append("\\\\"); break;
+ case '\n': builder.Append("\\n"); break;
+ case '\r': builder.Append("\\r"); break;
+ case '\t': builder.Append("\\t"); break;
+ case '\b': builder.Append("\\b"); break;
+ case '\f': builder.Append("\\f"); break;
+ default:
+ if (c < ' ')
+ {
+ builder.Append("\\u").Append(((int)c).ToString("x4", CultureInfo.InvariantCulture));
+ }
+ else
+ {
+ builder.Append(c);
+ }
+ break;
+ }
+ }
+ return builder.Append('"').ToString();
+ }
+
+ public static string Literal(object? value) => value switch
+ {
+ null => "null",
+ string text => EscapeString(text),
+ Guid guid => EscapeString(guid.ToString("D")),
+ bool boolean => boolean ? "true" : "false",
+ int or long => Convert.ToString(value, CultureInfo.InvariantCulture)!,
+ float single when !float.IsNaN(single) && !float.IsInfinity(single) => single.ToString("R", CultureInfo.InvariantCulture),
+ double number when !double.IsNaN(number) && !double.IsInfinity(number) => number.ToString("R", CultureInfo.InvariantCulture),
+ _ => throw new NotSupportedException($"Unsupported Milvus filter value '{value.GetType()}'."),
+ };
+}
diff --git a/MEVD/src/Milvus/MilvusFilterTranslator.cs b/MEVD/src/Milvus/MilvusFilterTranslator.cs
new file mode 100644
index 0000000..797df79
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusFilterTranslator.cs
@@ -0,0 +1,201 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using System.Linq.Expressions;
+using Microsoft.Extensions.VectorData.ProviderServices;
+using Microsoft.Extensions.VectorData.ProviderServices.Filter;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal sealed class MilvusFilterTranslator : FilterTranslatorBase
+{
+ private string _keyField = null!;
+
+ public string Translate(LambdaExpression filter, CollectionModel model)
+ {
+ _keyField = model.KeyProperty.StorageName;
+ return Translate(PreprocessFilter(filter, model, new FilterPreprocessingOptions()), predicate: true);
+ }
+
+ // Primary keys are never null. These are valid Milvus predicates, unlike bare true/false.
+ private string ConstantPredicate(bool value) => $"({_keyField} is {(value ? "not " : "")}null)";
+
+ private string Translate(Expression expression, bool predicate = false)
+ {
+ if (TryBindProperty(expression, out var property))
+ {
+ if (property is VectorPropertyModel)
+ {
+ throw new NotSupportedException("Milvus filters cannot reference vector fields.");
+ }
+ return predicate && property.Type == typeof(bool) ? $"({property.StorageName} == true)" : property.StorageName;
+ }
+ return expression switch
+ {
+ ConstantExpression { Value: bool value } when predicate => ConstantPredicate(value),
+ ConstantExpression constant => MilvusFieldMapping.Literal(constant.Value),
+ UnaryExpression { NodeType: ExpressionType.Convert } convert
+ when Nullable.GetUnderlyingType(convert.Type) == convert.Operand.Type => Translate(convert.Operand, predicate),
+ UnaryExpression { NodeType: ExpressionType.Not } not => TranslateNegated(not.Operand),
+ BinaryExpression binary => TranslateBinary(binary),
+ MethodCallExpression call when TryMatchContains(call, out var source, out var item)
+ => TryBindProperty(source, out var arrayProperty) && MilvusFieldMapping.GetElementType(arrayProperty.Type) is not null
+ ? TranslateArrayContains(arrayProperty.StorageName, ConstantValue(item))
+ : source switch
+ {
+ ConstantExpression { Value: IEnumerable values and not string } => TranslateContains(values, item),
+ NewArrayExpression { NodeType: ExpressionType.NewArrayInit } array
+ => TranslateContains(array.Expressions.Select(ConstantValue).ToArray(), item),
+ _ => throw new NotSupportedException("Milvus Contains requires a constant collection of scalar values."),
+ },
+ MethodCallExpression { Method.Name: nameof(Enumerable.Any), Arguments: [var source, LambdaExpression lambda] }
+ when lambda.Body is MethodCallExpression call && TryMatchContains(call, out var values, out var item)
+ && item == lambda.Parameters[0] && TryBindProperty(source, out var anyProperty)
+ && MilvusFieldMapping.GetElementType(anyProperty.Type) is not null
+ => TranslateAny(anyProperty.StorageName, values),
+ _ => throw new NotSupportedException($"Unsupported Milvus filter expression: {expression.NodeType}."),
+ };
+ }
+
+ private string TranslateNegated(Expression expression)
+ => expression switch
+ {
+ UnaryExpression { NodeType: ExpressionType.Not } not => Translate(not.Operand, predicate: true),
+ BinaryExpression { NodeType: ExpressionType.AndAlso } and => $"({TranslateNegated(and.Left)} or {TranslateNegated(and.Right)})",
+ BinaryExpression { NodeType: ExpressionType.OrElse } or => $"({TranslateNegated(or.Left)} and {TranslateNegated(or.Right)})",
+ MethodCallExpression call when TryMatchContains(call, out var source, out var item)
+ && TryBindProperty(source, out var property) && MilvusFieldMapping.GetElementType(property.Type) is not null
+ => TranslateArrayContains(property.StorageName, ConstantValue(item), negated: true),
+ MethodCallExpression { Method.Name: nameof(Enumerable.Any), Arguments: [var source, LambdaExpression lambda] }
+ when lambda.Body is MethodCallExpression call && TryMatchContains(call, out var values, out var item)
+ && item == lambda.Parameters[0] && TryBindProperty(source, out var property)
+ && MilvusFieldMapping.GetElementType(property.Type) is not null
+ => TranslateAny(property.StorageName, values, negated: true),
+ _ => $"(not {Translate(expression, predicate: true)})",
+ };
+
+ private string TranslateArrayContains(string name, object? value, bool negated = false)
+ => value is null ? ConstantPredicate(negated)
+ : GuardArrayMembership(name, $"array_contains({name}, {MilvusFieldMapping.Literal(value)})", negated);
+
+ private static string GuardArrayMembership(string name, string membership, bool negated)
+ // Milvus 2.5.27 can retain an unknown result under NOT even with an AND null guard.
+ // An explicit null arm keeps the negated predicate true for null arrays.
+ => negated ? $"({name} is null or not {membership})" : $"({name} is not null and {membership})";
+
+ private string TranslateAny(string name, Expression values, bool negated = false)
+ {
+ var elements = values switch
+ {
+ ConstantExpression { Value: IEnumerable enumerable } => enumerable.Cast(),
+ NewArrayExpression array => array.Expressions.Select(ConstantValue),
+ _ => throw new NotSupportedException("Milvus array membership requires constant values."),
+ };
+ var literals = elements.Where(value => value is not null).Select(MilvusFieldMapping.Literal).ToArray();
+ return literals.Length == 0 ? ConstantPredicate(negated)
+ : GuardArrayMembership(name, $"array_contains_any({name}, [{string.Join(", ", literals)}])", negated);
+ }
+
+ private static object? ConstantValue(Expression expression) => expression switch
+ {
+ ConstantExpression constant => constant.Value,
+ UnaryExpression { NodeType: ExpressionType.Convert } convert
+ when Nullable.GetUnderlyingType(convert.Type) == convert.Operand.Type => ConstantValue(convert.Operand),
+ _ => throw new NotSupportedException("Milvus inline filter arrays require constant values."),
+ };
+
+ private string TranslateContains(IEnumerable values, Expression item)
+ {
+ if (!TryBindProperty(item, out var property) || property is VectorPropertyModel)
+ {
+ throw new NotSupportedException("Milvus Contains must test a scalar property.");
+ }
+ var elements = values.Cast().ToArray();
+ var literals = elements.Where(value => value is not null).Select(MilvusFieldMapping.Literal).ToArray();
+ var membership = literals.Length == 0 ? ConstantPredicate(false) : $"({Translate(item)} in [{string.Join(", ", literals)}])";
+ if (!property.Type.IsValueType || Nullable.GetUnderlyingType(property.Type) is not null)
+ {
+ return elements.Contains(null)
+ ? $"({property.StorageName} is null or {membership})"
+ : literals.Length == 0 ? ConstantPredicate(false) : $"({property.StorageName} is not null and {membership})";
+ }
+ return membership;
+ }
+
+ private static bool IsNull(Expression expression) => expression switch
+ {
+ ConstantExpression { Value: null } => true,
+ UnaryExpression { NodeType: ExpressionType.Convert } convert => IsNull(convert.Operand),
+ _ => false,
+ };
+
+ private string TranslateBinary(BinaryExpression binary)
+ {
+ var op = binary.NodeType switch
+ {
+ ExpressionType.Equal => "==", ExpressionType.NotEqual => "!=",
+ ExpressionType.GreaterThan => ">", ExpressionType.GreaterThanOrEqual => ">=",
+ ExpressionType.LessThan => "<", ExpressionType.LessThanOrEqual => "<=",
+ ExpressionType.AndAlso => "and", ExpressionType.OrElse => "or",
+ _ => throw new NotSupportedException($"Unsupported Milvus filter operator: {binary.NodeType}."),
+ };
+ if (binary.NodeType is ExpressionType.Equal or ExpressionType.NotEqual)
+ {
+ if (binary.Right is ConstantExpression { Value: null })
+ {
+ return $"({Translate(binary.Left)} is {(binary.NodeType == ExpressionType.NotEqual ? "not " : "")}null)";
+ }
+ if (binary.Left is ConstantExpression { Value: null })
+ {
+ return $"({Translate(binary.Right)} is {(binary.NodeType == ExpressionType.NotEqual ? "not " : "")}null)";
+ }
+ }
+ if (binary.NodeType is ExpressionType.GreaterThan or ExpressionType.GreaterThanOrEqual
+ or ExpressionType.LessThan or ExpressionType.LessThanOrEqual
+ && (IsNull(binary.Left) || IsNull(binary.Right)))
+ {
+ // Lifted relational operators are false if either operand is null, including
+ // captured nullable variables after filter preprocessing.
+ return ConstantPredicate(false);
+ }
+ var logical = binary.NodeType is ExpressionType.AndAlso or ExpressionType.OrElse;
+ var translated = $"({Translate(binary.Left, logical)} {op} {Translate(binary.Right, logical)})";
+ if (binary.NodeType is ExpressionType.AndAlso or ExpressionType.OrElse)
+ {
+ return translated;
+ }
+ // Milvus uses three-valued null logic. Make comparisons total so C# negation and !=
+ // also match rows whose nullable scalar field is null.
+ if (TryBindProperty(binary.Left, out var leftField) && IsNullable(leftField.Type)
+ && TryBindProperty(binary.Right, out var rightField) && IsNullable(rightField.Type))
+ {
+ // Two nullable fields: in C#, == matches two nulls, != matches one null, and a relational operator is false with a null.
+ var (a, b) = (leftField.StorageName, rightField.StorageName);
+ var bothNotNull = $"{a} is not null and {b} is not null and {translated}";
+ return binary.NodeType switch
+ {
+ ExpressionType.Equal => $"(({a} is null and {b} is null) or ({bothNotNull}))",
+ ExpressionType.NotEqual => $"(({a} is null and {b} is not null) or ({a} is not null and {b} is null) or ({bothNotNull}))",
+ _ => $"({bothNotNull})",
+ };
+ }
+ PropertyModel? nullableProperty = null;
+ if (TryBindProperty(binary.Left, out var left) && IsNullable(left.Type)
+ && binary.Right is ConstantExpression or UnaryExpression { NodeType: ExpressionType.Convert })
+ {
+ nullableProperty = left;
+ }
+ else if (TryBindProperty(binary.Right, out var right) && IsNullable(right.Type)
+ && binary.Left is ConstantExpression or UnaryExpression { NodeType: ExpressionType.Convert })
+ {
+ nullableProperty = right;
+ }
+ return nullableProperty is null ? translated
+ : binary.NodeType == ExpressionType.NotEqual
+ ? $"({nullableProperty.StorageName} is null or {translated})"
+ : $"({nullableProperty.StorageName} is not null and {translated})";
+
+ static bool IsNullable(Type type) => !type.IsValueType || Nullable.GetUnderlyingType(type) is not null;
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusMapper.cs b/MEVD/src/Milvus/MilvusMapper.cs
new file mode 100644
index 0000000..9e7e83c
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusMapper.cs
@@ -0,0 +1,89 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData.ProviderServices;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal sealed class MilvusMapper(CollectionModel model) where TRecord : class
+{
+ public IDictionary MapFromDataToStorageModel(TRecord record, int recordIndex,
+ GeneratedEmbeddings>?[]? generatedEmbeddings)
+ {
+ var key = model.KeyProperty.GetValueAsObject(record)
+ ?? throw new InvalidOperationException("The key cannot be null.");
+ Dictionary row = new(StringComparer.Ordinal)
+ {
+ [model.KeyProperty.StorageName] = MilvusFieldMapping.ToKey(key),
+ };
+ foreach (var property in model.DataProperties)
+ {
+ var value = property.GetValueAsObject(record);
+ if (value is IEnumerable elements && MilvusFieldMapping.GetElementType(property.Type) is not null)
+ {
+ var elementIndex = 0;
+ foreach (var element in elements)
+ {
+ if (element is null)
+ {
+ throw new ArgumentException(
+ $"Record '{key}' (batch index {recordIndex}) has a null element at index {elementIndex} in array property '{property.ModelName}' (storage field '{property.StorageName}'). Milvus array elements cannot be null.",
+ nameof(record));
+ }
+ elementIndex++;
+ }
+ }
+ row[property.StorageName] = value;
+ }
+ for (var i = 0; i < model.VectorProperties.Count; i++)
+ {
+ var property = model.VectorProperties[i];
+ var vector = GetVector(generatedEmbeddings?[i] is { } embeddings
+ ? embeddings[recordIndex] : property.GetValueAsObject(record));
+ if (vector.Length != property.Dimensions)
+ {
+ throw new ArgumentException($"Vector '{property.ModelName}' must have {property.Dimensions} dimensions.");
+ }
+ row[property.StorageName] = vector;
+ }
+ return row;
+ }
+
+ internal static ReadOnlyMemory GetVector(object? value) => value switch
+ {
+ ReadOnlyMemory memory => memory,
+ float[] array => array,
+ Embedding embedding => embedding.Vector,
+ _ => throw new InvalidOperationException("A vector must be a non-null float array, ReadOnlyMemory or Embedding."),
+ };
+
+ public TRecord MapFromStorageToDataModel(IReadOnlyDictionary row, bool includeVectors)
+ {
+ var record = model.CreateRecord()!;
+ var key = row[model.KeyProperty.StorageName]!;
+ model.KeyProperty.SetValueAsObject(record, model.KeyProperty.Type == typeof(Guid) ? Guid.Parse((string)key) : key);
+ foreach (var property in model.DataProperties)
+ {
+ if (row.TryGetValue(property.StorageName, out var value))
+ {
+ property.SetValueAsObject(record, MilvusFieldMapping.ReadValue(value, property.Type));
+ }
+ }
+ if (includeVectors)
+ {
+ foreach (var property in model.VectorProperties)
+ {
+ if (row.TryGetValue(property.StorageName, out var value))
+ {
+ var vector = GetVector(value);
+ var type = Nullable.GetUnderlyingType(property.Type) ?? property.Type;
+ property.SetValueAsObject(record, type == typeof(float[]) ? vector.ToArray()
+ : type == typeof(Embedding) ? new Embedding(vector) : (object)vector);
+ }
+ }
+ }
+ return record;
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusModelBuilder.cs b/MEVD/src/Milvus/MilvusModelBuilder.cs
new file mode 100644
index 0000000..f13e2b1
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusModelBuilder.cs
@@ -0,0 +1,117 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
+using Microsoft.Extensions.VectorData.ProviderServices;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+internal sealed class MilvusModelBuilder() : CollectionModelBuilder(new()
+{
+ RequiresAtLeastOneVector = true,
+ SupportsMultipleVectors = true,
+})
+{
+ // Reserved tokens from Milvus 2.6's Plan.g4 grammar cannot be unquoted field names.
+ private static readonly HashSet s_reservedNames = new(StringComparer.OrdinalIgnoreCase)
+ {
+ "like", "exists", "text_match", "phrase_match", "random_sample", "interval", "iso",
+ "and", "or", "not", "in", "true", "false", "null", "is",
+ "json_contains", "json_contains_all", "json_contains_any",
+ "array_contains", "array_contains_all", "array_contains_any", "array_length",
+ "st_equals", "st_touches", "st_overlaps", "st_crosses", "st_contains", "st_intersects", "st_within", "st_dwithin",
+ };
+
+ internal const string SupportedVectorTypes = "ReadOnlyMemory, Embedding, float[]";
+
+ private const int MaxFieldNameLength = 255;
+
+ protected override void ValidateKeyProperty(KeyPropertyModel keyProperty)
+ {
+ base.ValidateKeyProperty(keyProperty);
+ if (keyProperty.Type != typeof(long) && keyProperty.Type != typeof(string) && keyProperty.Type != typeof(Guid))
+ {
+ throw new NotSupportedException("Milvus keys must be long, string or Guid.");
+ }
+ if (keyProperty.IsAutoGenerated && keyProperty.Type != typeof(Guid))
+ {
+ throw new NotSupportedException("Auto-generation is supported only for Guid keys.");
+ }
+ }
+
+ protected override void ValidateProperty(PropertyModel propertyModel, VectorStoreCollectionDefinition? definition)
+ {
+ base.ValidateProperty(propertyModel, definition);
+ var name = propertyModel.StorageName;
+ if (name.Length == 0 || name.Length > MaxFieldNameLength || !(IsLetter(name[0]) || name[0] == '_')
+ || name.Any(c => !(IsLetter(c) || c is >= '0' and <= '9' || c == '_')))
+ {
+ throw new NotSupportedException($"Invalid Milvus field name '{name}'. Use ASCII letters, digits and underscores, starting with a letter or underscore.");
+ }
+ if (s_reservedNames.Contains(name))
+ {
+ throw new NotSupportedException($"Milvus field name '{name}' is a reserved keyword. Configure a different StorageName.");
+ }
+ if (propertyModel is VectorPropertyModel vector)
+ {
+ _ = MilvusCollectionCreateMapping.GetMetric(vector);
+ _ = MilvusCollectionCreateMapping.GetIndexType(vector);
+ }
+ if (propertyModel is DataPropertyModel { IsFullTextIndexed: true } dataProperty)
+ {
+ if (dataProperty.Type != typeof(string))
+ {
+ throw new InvalidOperationException($"Property {nameof(VectorStoreDataProperty.IsFullTextIndexed)} on {nameof(VectorStoreDataProperty)} '{dataProperty.ModelName}' is set to true, but the property type is not a string. The Milvus VectorStore supports {nameof(VectorStoreDataProperty.IsFullTextIndexed)} on string properties only.");
+ }
+ var bm25FieldName = MilvusCollectionCreateMapping.GetBm25FieldName(dataProperty);
+ if (bm25FieldName.Length > MaxFieldNameLength)
+ {
+ throw new NotSupportedException($"Milvus field name '{name}' is too long for full-text indexing: its BM25 field '{bm25FieldName}' would exceed {MaxFieldNameLength} characters. Configure a shorter StorageName.");
+ }
+ }
+
+ static bool IsLetter(char c) => c is >= 'a' and <= 'z' or >= 'A' and <= 'Z';
+ }
+
+ protected override void Validate(Type? type, VectorStoreCollectionDefinition? definition)
+ {
+ base.Validate(type, definition);
+
+ // Each full-text indexed property adds a hidden BM25 field, which no property can be stored under.
+ foreach (var fullTextProperty in DataProperties.Where(p => p.IsFullTextIndexed))
+ {
+ var bm25FieldName = MilvusCollectionCreateMapping.GetBm25FieldName(fullTextProperty);
+ if (Properties.FirstOrDefault(p => p.StorageName == bm25FieldName) is { } conflict)
+ {
+ throw new InvalidOperationException($"Property '{conflict.ModelName}' is mapped to storage name '{bm25FieldName}', which the Milvus VectorStore uses for the BM25 field of the full-text indexed property '{fullTextProperty.ModelName}'. Configure a different StorageName.");
+ }
+ }
+ }
+
+ protected override bool IsDataPropertyTypeValid(Type type, [NotNullWhen(false)] out string? supportedTypes)
+ {
+ supportedTypes = "string, int, long, float, double, bool, nullable versions of these value types, and arrays/lists of non-nullable scalars";
+ if (MilvusFieldMapping.GetElementType(type) is { } elementType)
+ {
+ type = elementType;
+ }
+ else
+ {
+ type = Nullable.GetUnderlyingType(type) ?? type;
+ }
+ return type == typeof(string) || type == typeof(int) || type == typeof(long)
+ || type == typeof(float) || type == typeof(double) || type == typeof(bool);
+ }
+
+ protected override bool IsVectorPropertyTypeValid(Type type, [NotNullWhen(false)] out string? supportedTypes)
+ => IsVectorPropertyTypeValidCore(type, out supportedTypes);
+
+ internal static bool IsVectorPropertyTypeValidCore(Type type, [NotNullWhen(false)] out string? supportedTypes)
+ {
+ supportedTypes = SupportedVectorTypes;
+ return type == typeof(ReadOnlyMemory) || type == typeof(ReadOnlyMemory?)
+ || type == typeof(Embedding) || type == typeof(float[]);
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusServiceCollectionExtensions.cs b/MEVD/src/Milvus/MilvusServiceCollectionExtensions.cs
new file mode 100644
index 0000000..61b05c1
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusServiceCollectionExtensions.cs
@@ -0,0 +1,328 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
+using CommunityToolkit.VectorData.Milvus;
+using Milvus.Client;
+using Microsoft.Shared.Diagnostics;
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+///
+/// Extension methods to register and instances on an .
+///
+public static class MilvusServiceCollectionExtensions
+{
+ private const string DynamicCodeMessage = "This method is incompatible with NativeAOT, consult the documentation for adding collections in a way that's compatible with NativeAOT.";
+ private const string UnreferencedCodeMessage = "This method is incompatible with trimming, consult the documentation for adding collections in a way that's compatible with NativeAOT.";
+
+ ///
+ /// Registers a as
+ /// with returned by
+ /// or retrieved from the dependency injection container if was not provided.
+ ///
+ ///
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddMilvusVectorStore(
+ this IServiceCollection services,
+ Func? clientProvider = default,
+ Func? optionsProvider = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ => AddKeyedMilvusVectorStore(services, serviceKey: null, clientProvider, optionsProvider, lifetime);
+
+ ///
+ /// Registers a keyed as
+ /// with returned by or retrieved from the dependency injection container if was not provided.
+ ///
+ /// The to register the on.
+ /// The key with which to associate the vector store.
+ /// The provider.
+ /// Options provider to further configure the .
+ /// The service lifetime for the store. Defaults to .
+ /// Service collection.
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddKeyedMilvusVectorStore(
+ this IServiceCollection services,
+ object? serviceKey,
+ Func? clientProvider = default,
+ Func? optionsProvider = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ => AddKeyedMilvusVectorStoreCore(services, serviceKey, clientProvider, optionsProvider, lifetime, ownsClient: false);
+
+ private static IServiceCollection AddKeyedMilvusVectorStoreCore(
+ this IServiceCollection services,
+ object? serviceKey,
+ Func? clientProvider,
+ Func? optionsProvider,
+ ServiceLifetime lifetime, bool ownsClient, string? databaseName = null)
+ {
+ Throw.IfNull(services);
+
+ services.Add(new ServiceDescriptor(typeof(MilvusVectorStore), serviceKey, (sp, _) =>
+ {
+ var client = clientProvider is null ? sp.GetRequiredService() : clientProvider(sp);
+ var options = GetStoreOptions(sp, optionsProvider);
+
+ // Clients created by host overloads are owned, and their database is known; supplied clients remain caller-owned.
+ return new MilvusVectorStore(new SharedMilvusClient(client, ownsClient, databaseName), options);
+ }, lifetime));
+
+ services.Add(new ServiceDescriptor(typeof(VectorStore), serviceKey,
+ static (sp, key) => sp.GetRequiredKeyedService(key), lifetime));
+
+ return services;
+ }
+
+ ///
+ /// Registers a as
+ /// with created with , ,
+ /// and .
+ ///
+ ///
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddMilvusVectorStore(
+ this IServiceCollection services,
+ string host,
+ int port = 19530,
+ bool https = false,
+ string? apiKey = default,
+ string? database = null,
+ string? username = null,
+ string? password = null,
+ MilvusVectorStoreOptions? options = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ => AddKeyedMilvusVectorStore(services, serviceKey: null, host, port, https, apiKey, database, username, password, options, lifetime);
+
+ ///
+ /// Registers a keyed as
+ /// with created with , ,
+ /// and .
+ ///
+ /// The to register the on.
+ /// The key with which to associate the vector store.
+ /// The host to connect to.
+ /// The port to connect to. Defaults to 19530.
+ /// Whether to encrypt the connection using HTTPS. Defaults to false.
+ /// The API key to use. Cannot be combined with username/password credentials.
+ /// The database to connect to, or null for the default database.
+ /// The authentication username.
+ /// The authentication password. Required with username.
+ /// Options to further configure the .
+ /// The service lifetime for the store. Defaults to .
+ /// Service collection.
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddKeyedMilvusVectorStore(
+ this IServiceCollection services,
+ object? serviceKey,
+ string host,
+ int port = 19530,
+ bool https = false,
+ string? apiKey = default,
+ string? database = null,
+ string? username = null,
+ string? password = null,
+ MilvusVectorStoreOptions? options = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ {
+ Throw.IfNullOrWhitespace(host);
+
+ ValidateCredentials(apiKey, username, password);
+ return AddKeyedMilvusVectorStoreCore(services, serviceKey, _ => CreateClient(host, port, https, apiKey, database, username, password), _ => options,
+ lifetime, ownsClient: true, databaseName: database ?? "default");
+ }
+
+ ///
+ /// Registers a as
+ /// with returned by or retrieved from the dependency injection container if was not provided.
+ ///
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddMilvusCollection(
+ this IServiceCollection services,
+ string name,
+ Func? clientProvider = default,
+ Func? optionsProvider = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ where TKey : notnull
+ where TRecord : class
+ => AddKeyedMilvusCollection(services, serviceKey: null, name, clientProvider, optionsProvider, lifetime);
+
+ ///
+ /// Registers a keyed as
+ /// with returned by or retrieved from the dependency injection container if was not provided.
+ ///
+ /// The to register the on.
+ /// The key with which to associate the collection.
+ /// The name of the collection.
+ /// The provider.
+ /// Options provider to further configure the .
+ /// The service lifetime for the store. Defaults to .
+ /// Service collection.
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddKeyedMilvusCollection(
+ this IServiceCollection services,
+ object? serviceKey,
+ string name,
+ Func? clientProvider = default,
+ Func? optionsProvider = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ where TKey : notnull
+ where TRecord : class
+ => AddKeyedMilvusCollectionCore(services, serviceKey, name, clientProvider, optionsProvider, lifetime, ownsClient: false);
+
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ private static IServiceCollection AddKeyedMilvusCollectionCore(
+ this IServiceCollection services,
+ object? serviceKey,
+ string name,
+ Func? clientProvider,
+ Func? optionsProvider,
+ ServiceLifetime lifetime, bool ownsClient, string? databaseName = null)
+ where TKey : notnull
+ where TRecord : class
+ {
+ Throw.IfNull(services);
+ Throw.IfNullOrWhitespace(name);
+
+ services.Add(new ServiceDescriptor(typeof(MilvusCollection), serviceKey, (sp, _) =>
+ {
+ var client = clientProvider is null ? sp.GetRequiredService() : clientProvider(sp);
+ var options = GetCollectionOptions(sp, optionsProvider);
+
+ // Clients created by host overloads are owned, and their database is known; supplied clients remain caller-owned.
+ return new MilvusCollection(() => new SharedMilvusClient(client, ownsClient, databaseName), name, options);
+ }, lifetime));
+
+ services.Add(new ServiceDescriptor(typeof(VectorStoreCollection), serviceKey,
+ static (sp, key) => sp.GetRequiredKeyedService>(key), lifetime));
+
+ services.Add(new ServiceDescriptor(typeof(IVectorSearchable), serviceKey,
+ static (sp, key) => sp.GetRequiredKeyedService>(key), lifetime));
+
+ services.Add(new ServiceDescriptor(typeof(IKeywordHybridSearchable), serviceKey,
+ static (sp, key) => sp.GetRequiredKeyedService>(key), lifetime));
+
+ return services;
+ }
+
+ ///
+ /// Registers a as
+ /// with created with , ,
+ /// and .
+ ///
+ ///
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddMilvusCollection(
+ this IServiceCollection services,
+ string name,
+ string host,
+ int port = 19530,
+ bool https = false,
+ string? apiKey = default,
+ string? database = null,
+ string? username = null,
+ string? password = null,
+ MilvusCollectionOptions? options = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ where TKey : notnull
+ where TRecord : class
+ => AddKeyedMilvusCollection(services, serviceKey: null, name, host, port, https, apiKey, database, username, password, options, lifetime);
+
+ ///
+ /// Registers a keyed as
+ /// with created with , ,
+ /// and .
+ ///
+ /// The to register the on.
+ /// The key with which to associate the collection.
+ /// The name of the collection.
+ /// The host to connect to.
+ /// The port to connect to. Defaults to 19530.
+ /// Whether to encrypt the connection using HTTPS. Defaults to false.
+ /// The API key to use. Cannot be combined with username/password credentials.
+ /// The database to connect to, or null for the default database.
+ /// The authentication username.
+ /// The authentication password. Required with username.
+ /// Options to further configure the .
+ /// The service lifetime for the store. Defaults to .
+ /// Service collection.
+ [RequiresUnreferencedCode(UnreferencedCodeMessage)]
+ [RequiresDynamicCode(DynamicCodeMessage)]
+ public static IServiceCollection AddKeyedMilvusCollection(
+ this IServiceCollection services,
+ object? serviceKey,
+ string name,
+ string host,
+ int port = 19530,
+ bool https = false,
+ string? apiKey = default,
+ string? database = null,
+ string? username = null,
+ string? password = null,
+ MilvusCollectionOptions? options = default,
+ ServiceLifetime lifetime = ServiceLifetime.Singleton)
+ where TKey : notnull
+ where TRecord : class
+ {
+ Throw.IfNullOrWhitespace(host);
+
+ ValidateCredentials(apiKey, username, password);
+ return AddKeyedMilvusCollectionCore(services, serviceKey, name, _ => CreateClient(host, port, https, apiKey, database, username, password), _ => options,
+ lifetime, ownsClient: true, databaseName: database ?? "default");
+ }
+
+ private static void ValidateCredentials(string? apiKey, string? username, string? password)
+ {
+ if ((username is null) != (password is null))
+ {
+ throw new ArgumentException("Username and password must be provided together.");
+ }
+ if (apiKey is not null && username is not null)
+ {
+ throw new ArgumentException("API key and username/password authentication cannot be combined.");
+ }
+ }
+
+ private static MilvusClient CreateClient(string host, int port, bool https, string? apiKey,
+ string? database, string? username, string? password)
+ => username is not null ? new MilvusClient(host, username, password!, port, https, database)
+ : apiKey is not null ? new MilvusClient(host, apiKey, port, https, database)
+ : new MilvusClient(host, port, https, database);
+
+ private static MilvusVectorStoreOptions? GetStoreOptions(IServiceProvider sp, Func? optionsProvider)
+ {
+ var options = optionsProvider?.Invoke(sp);
+ if (options?.EmbeddingGenerator is not null)
+ {
+ return options; // The user has provided everything, there is nothing to change.
+ }
+
+ var embeddingGenerator = sp.GetService();
+ return embeddingGenerator is null
+ ? options // There is nothing to change.
+ : new(options) { EmbeddingGenerator = embeddingGenerator }; // Create a brand new copy in order to avoid modifying the original options.
+ }
+
+ private static MilvusCollectionOptions? GetCollectionOptions(IServiceProvider sp, Func? optionsProvider)
+ {
+ var options = optionsProvider?.Invoke(sp);
+ if (options?.EmbeddingGenerator is not null)
+ {
+ return options; // The user has provided everything, there is nothing to change.
+ }
+
+ var embeddingGenerator = sp.GetService();
+ return embeddingGenerator is null
+ ? options // There is nothing to change.
+ : new(options) { EmbeddingGenerator = embeddingGenerator }; // Create a brand new copy in order to avoid modifying the original options.
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusVectorStore.cs b/MEVD/src/Milvus/MilvusVectorStore.cs
new file mode 100644
index 0000000..5bb2713
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusVectorStore.cs
@@ -0,0 +1,151 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using Milvus.Client;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
+using Microsoft.Extensions.VectorData.ProviderServices;
+using Microsoft.Shared.Diagnostics;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// Class for accessing the list of collections in a Milvus vector store.
+///
+///
+/// This class can be used with collections of any schema type, but requires you to provide schema information when getting a collection.
+///
+public sealed class MilvusVectorStore : VectorStore
+{
+ /// Metadata about vector store.
+ private readonly VectorStoreMetadata _metadata;
+
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ private readonly SharedMilvusClient _milvusClient;
+
+ /// A general purpose definition that can be used to construct a collection when needing to proxy schema agnostic operations.
+ private static readonly VectorStoreCollectionDefinition s_generalPurposeDefinition = new() { Properties = [new VectorStoreKeyProperty("Key", typeof(string)), new VectorStoreVectorProperty("Vector", typeof(ReadOnlyMemory), 1)] };
+
+ private readonly IEmbeddingGenerator? _embeddingGenerator;
+
+ /// Whether the store was disposed: it releases its share of the client only once.
+ private int _disposed;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ /// A value indicating whether is disposed after the vector store and the collections it returns are all disposed.
+ /// Optional configuration options for this class.
+ public MilvusVectorStore(MilvusClient milvusClient, bool ownsClient, MilvusVectorStoreOptions? options = default)
+ : this(new SharedMilvusClient(milvusClient, ownsClient), options)
+ {
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ /// Optional configuration options for this class.
+ internal MilvusVectorStore(SharedMilvusClient milvusClient, MilvusVectorStoreOptions? options = default)
+ {
+ Throw.IfNull(milvusClient);
+
+ _milvusClient = milvusClient;
+
+ options ??= MilvusVectorStoreOptions.Default;
+ _embeddingGenerator = options.EmbeddingGenerator;
+
+ _metadata = new()
+ {
+ VectorStoreSystemName = MilvusConstants.VectorStoreSystemName,
+ VectorStoreName = milvusClient.DatabaseName
+ };
+ }
+
+ ///
+ protected override void Dispose(bool disposing)
+ {
+ if (Interlocked.Exchange(ref _disposed, 1) == 0)
+ {
+ _milvusClient.Dispose();
+ }
+
+ base.Dispose(disposing);
+ }
+
+#pragma warning disable IDE0090 // Use 'new(...)'
+ ///
+ [RequiresDynamicCode("This overload of GetCollection() is incompatible with NativeAOT. For dynamic mapping via Dictionary, call GetDynamicCollection() instead.")]
+ [RequiresUnreferencedCode("This overload of GetCollection() is incompatible with trimming. For dynamic mapping via Dictionary, call GetDynamicCollection() instead.")]
+#if NET
+ public override MilvusCollection GetCollection(string name, VectorStoreCollectionDefinition? definition = null)
+#else
+ public override VectorStoreCollection GetCollection(string name, VectorStoreCollectionDefinition? definition = null)
+#endif
+ => typeof(TRecord) == typeof(Dictionary)
+ ? throw new ArgumentException(VectorDataStrings.GetCollectionWithDictionaryNotSupported)
+ : new MilvusCollection(_milvusClient.Share, name, new()
+ {
+ Definition = definition,
+ EmbeddingGenerator = _embeddingGenerator
+ });
+
+ ///
+#if NET
+ public override MilvusDynamicCollection GetDynamicCollection(string name, VectorStoreCollectionDefinition definition)
+#else
+ public override VectorStoreCollection> GetDynamicCollection(string name, VectorStoreCollectionDefinition definition)
+#endif
+ => new MilvusDynamicCollection(_milvusClient.Share, name, new MilvusCollectionOptions()
+ {
+ Definition = definition,
+ EmbeddingGenerator = _embeddingGenerator
+ });
+#pragma warning restore IDE0090
+
+ ///
+ public override async IAsyncEnumerable ListCollectionNamesAsync([EnumeratorCancellation] CancellationToken cancellationToken = default)
+ {
+ const string OperationName = "ListCollectionNames";
+
+ var collections = await MilvusErrorHandler.RunAsync>(
+ new VectorStoreCollectionMetadata { VectorStoreSystemName = MilvusConstants.VectorStoreSystemName, VectorStoreName = _milvusClient.DatabaseName },
+ OperationName,
+ () => _milvusClient.Client.ListCollectionsAsync(cancellationToken: cancellationToken)).ConfigureAwait(false);
+
+ foreach (var collection in collections)
+ {
+ yield return collection.Name;
+ }
+ }
+
+ ///
+ public override async Task CollectionExistsAsync(string name, CancellationToken cancellationToken = default)
+ {
+ using var collection = GetDynamicCollection(name, s_generalPurposeDefinition);
+ return await collection.CollectionExistsAsync(cancellationToken).ConfigureAwait(false);
+ }
+
+ ///
+ public override async Task EnsureCollectionDeletedAsync(string name, CancellationToken cancellationToken = default)
+ {
+ using var collection = GetDynamicCollection(name, s_generalPurposeDefinition);
+ await collection.EnsureCollectionDeletedAsync(cancellationToken).ConfigureAwait(false);
+ }
+
+ ///
+ public override object? GetService(Type serviceType, object? serviceKey = null)
+ {
+ Throw.IfNull(serviceType);
+
+ return
+ serviceKey is not null ? null :
+ serviceType == typeof(VectorStoreMetadata) ? _metadata :
+ serviceType == typeof(MilvusClient) ? _milvusClient.Client :
+ serviceType.IsInstanceOfType(this) ? this :
+ null;
+ }
+}
diff --git a/MEVD/src/Milvus/MilvusVectorStoreOptions.cs b/MEVD/src/Milvus/MilvusVectorStoreOptions.cs
new file mode 100644
index 0000000..e71571d
--- /dev/null
+++ b/MEVD/src/Milvus/MilvusVectorStoreOptions.cs
@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.AI;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// Options when creating a .
+///
+public sealed class MilvusVectorStoreOptions
+{
+ internal static readonly MilvusVectorStoreOptions Default = new();
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ public MilvusVectorStoreOptions()
+ {
+ }
+
+ internal MilvusVectorStoreOptions(MilvusVectorStoreOptions? source)
+ {
+ EmbeddingGenerator = source?.EmbeddingGenerator;
+ }
+
+
+ ///
+ /// Gets or sets the default embedding generator to use when generating vector embeddings with this vector store.
+ ///
+ public IEmbeddingGenerator? EmbeddingGenerator { get; set; }
+}
diff --git a/MEVD/src/Milvus/README.md b/MEVD/src/Milvus/README.md
new file mode 100644
index 0000000..cb370b5
--- /dev/null
+++ b/MEVD/src/Milvus/README.md
@@ -0,0 +1,63 @@
+# CommunityToolkit.VectorData.Milvus
+
+Milvus provider for [Microsoft.Extensions.VectorData](https://learn.microsoft.com/dotnet/ai/vector-stores/overview), by the .NET Community Toolkit.
+
+[Milvus](https://milvus.io/) is an open-source vector database for AI applications.
+
+The provider is built on [Milvus.Client](https://www.nuget.org/packages/Milvus.Client), the Milvus C# SDK.
+
+Requires Milvus 2.6 or later.
+
+## Quick start
+
+1. Run Milvus with Docker, as a single container with embedded etcd and local storage:
+
+```bash
+docker run -d --name milvus -p 19530:19530 -e DEPLOY_MODE=STANDALONE -e ETCD_USE_EMBED=true -e COMMON_STORAGETYPE=local milvusdb/milvus:v2.6.25 milvus run standalone
+```
+
+For other setups, see the [standalone installation instructions](https://milvus.io/docs/install_standalone-docker.md).
+
+2. Install the NuGet package:
+
+```bash
+dotnet add package CommunityToolkit.VectorData.Milvus
+```
+
+For more information, see the [Microsoft.Extensions.VectorData documentation](https://learn.microsoft.com/dotnet/ai/vector-stores/overview).
+
+## Limitations
+
+- Milvus 2.5 is not supported: on Milvus 2.5.27, an upsert of a record with a string property fails with `the length of valid_data of field(...) is wrong`.
+- Keys can be `long`, `string`, or `Guid`. Auto-generation is supported only for Guid keys and happens in the provider before upsert.
+- Whole-array equality filters, date/time data, and ordered retrieval are not supported. Array membership via `Contains` and `Any` is supported.
+- `IsFullTextIndexed` is supported on string properties. Milvus analyzes the text with its default analyzer, and a BM25 function stores the result in a hidden sparse field: the storage name of the property with `_bm25`. No other property can use that name, so the storage name of a full-text indexed property can have at most 250 characters. Records read back do not include the hidden field.
+- Keyword hybrid search fuses a vector search and a BM25 search of the keywords on a full-text indexed property, both filtered, with Reciprocal Rank Fusion (k = 60). The keywords are searched as one text, analyzed like the property. Each of the two searches ranks at least 10 records, or `top` + `Skip` when more. Scores are RRF scores: a higher score ranks higher, and a score threshold is a lower bound. `GetService` returns `IKeywordHybridSearchable` only for a collection with a full-text indexed property.
+- An array or list property can be null or empty, but its individual elements cannot be null. The provider rejects null elements before calling the SDK and identifies the record, property and element index.
+- Supported metrics are cosine similarity (default), dot product similarity, Euclidean distance, and squared Euclidean distance. Scores are native Milvus scores, except Euclidean distance: the square root of the squared distance that Milvus returns. Distance thresholds are upper bounds, similarity thresholds are lower bounds.
+- `IsIndexed` does not create scalar indexes; Milvus can filter scalar fields without them. Supported vector indexes are automatic (default), Flat, and HNSW.
+- Field storage names must use ASCII letters, digits and underscores, starting with a letter or underscore. Reserved Milvus keywords are rejected during model construction. Varchar fields allow up to 65535 bytes. Schema changes on an existing collection require explicit management through the SDK.
+- Collection names must use ASCII letters, digits and underscores, start with a letter or underscore, and have at most 255 characters: Milvus rejects other names, such as `chathistory-local`.
+- For NativeAOT, use dynamic dictionary collections with explicit definitions: the typed collection APIs use reflection. Publishing with trimming or NativeAOT shows the warnings `IL2104` and `IL3053` of the dependency `Milvus.Client`.
+- On .NET Framework, `Milvus.Client` calls Milvus over WinHTTP (`WinHttpHandler`, which `Grpc.Net.Client` brings in). This needs:
+ - A TLS endpoint: `https: true` on the host-based registrations, or `ssl: true` on `MilvusClient`. A plaintext endpoint fails with `Response protocol downgraded to HTTP/1.1`.
+ - A server certificate that Windows trusts. To validate it another way, create the `MilvusClient` on a `GrpcChannel` with a `WinHttpHandler` and pass that client to the provider.
+ - Windows 11 or later. Windows Server 2019 and 2022 support gRPC over WinHTTP only partially. See [Microsoft's gRPC requirements for .NET Framework](https://learn.microsoft.com/aspnet/core/grpc/netstandard#net-framework).
+
+ Verified on Windows 11 with .NET Framework 4.7.2 against Milvus 2.6.25 over TLS.
+
+Host-based registrations accept `database`, `username`/`password`, or `apiKey`. The two authentication modes are mutually exclusive. Keyed variants are also available:
+
+```csharp
+builder.Services.AddMilvusVectorStore("milvus.example.com", https: true,
+ database: "catalog", username: "root", password: password);
+```
+
+Host-based registrations report the selected database as `VectorStoreName` in the metadata of the store and of its collections, or `default` when none is selected. An existing `MilvusClient` does not expose the database it uses, so with a supplied client `VectorStoreName` is null. Host-based registrations own their SDK client; supplied clients remain caller-owned:
+
+```csharp
+var client = new MilvusClient("milvus.example.com", port: 19530, ssl: true,
+ database: "catalog");
+
+builder.Services.AddMilvusVectorStore(_ => client);
+```
diff --git a/MEVD/src/Milvus/SharedMilvusClient.cs b/MEVD/src/Milvus/SharedMilvusClient.cs
new file mode 100644
index 0000000..b4a1347
--- /dev/null
+++ b/MEVD/src/Milvus/SharedMilvusClient.cs
@@ -0,0 +1,67 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.Client;
+using Microsoft.Shared.Diagnostics;
+
+namespace CommunityToolkit.VectorData.Milvus;
+
+///
+/// The of a vector store or of a collection. A vector store shares it with the collections it returns,
+/// and the it owns is disposed when the last of them is disposed.
+///
+internal sealed class SharedMilvusClient : IDisposable
+{
+ private readonly MilvusClient? _ownedClient;
+ private int _referenceCount = 1;
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// Milvus client that can be used to manage the collections and records in a Milvus store.
+ /// A value indicating whether is disposed with the last of the vector store and its collections.
+ ///
+ /// The database the SDK client connects to, for telemetry: known to the host-based registrations, which create the client.
+ ///
+ public SharedMilvusClient(MilvusClient milvusClient, bool ownsClient, string? databaseName = null)
+ {
+ Throw.IfNull(milvusClient);
+
+ Client = milvusClient;
+ DatabaseName = databaseName;
+ _ownedClient = ownsClient ? milvusClient : null;
+ }
+
+ ///
+ /// Gets the client.
+ ///
+ public MilvusClient Client { get; }
+
+ ///
+ /// Gets the database name for telemetry, or for a client created by the caller: the SDK does not
+ /// expose the configured database.
+ ///
+ public string? DatabaseName { get; }
+
+ ///
+ /// Gets this client for one more user, a collection of the vector store, which disposes it too.
+ ///
+ public SharedMilvusClient Share()
+ {
+ if (_ownedClient is not null)
+ {
+ Interlocked.Increment(ref _referenceCount);
+ }
+
+ return this;
+ }
+
+ ///
+ public void Dispose()
+ {
+ if (_ownedClient is not null && Interlocked.Decrement(ref _referenceCount) == 0)
+ {
+ _ownedClient.Dispose();
+ }
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/Milvus.ConformanceTests.csproj b/MEVD/test/Milvus.ConformanceTests/Milvus.ConformanceTests.csproj
new file mode 100644
index 0000000..bf3c562
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/Milvus.ConformanceTests.csproj
@@ -0,0 +1,25 @@
+
+
+
+
+
+ net10.0
+ enable
+ enable
+ true
+ false
+ Milvus.ConformanceTests
+
+
+
+
+
+
+
+
+
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusArrayFilterTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusArrayFilterTests.cs
new file mode 100644
index 0000000..5caa793
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusArrayFilterTests.cs
@@ -0,0 +1,72 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Linq.Expressions;
+using CommunityToolkit.VectorData.Milvus;
+using Microsoft.Extensions.VectorData;
+using Milvus.ConformanceTests.Support;
+using Xunit;
+
+namespace Milvus.ConformanceTests;
+
+public sealed class MilvusArrayFilterTests : IClassFixture
+{
+ [Fact]
+ public async Task ArrayMembershipPreservesNullSemanticsForRetrievalAndSearch()
+ {
+ using var collection = new MilvusCollection(MilvusTestStore.Instance.Client,
+ "ct_arrays_" + Guid.NewGuid().ToString("N"), ownsClient: false);
+ try
+ {
+ await collection.EnsureCollectionExistsAsync();
+ await collection.UpsertAsync(new[]
+ {
+ new Record { Id = "null" },
+ new Record { Id = "empty", Tags = [], ListTags = [] },
+ new Record { Id = "other", Tags = ["y"], ListTags = ["y"] },
+ new Record { Id = "match", Tags = ["x"], ListTags = ["x"] },
+ });
+ var candidates = new[] { "x", null };
+ var nulls = new string?[] { null };
+ var empty = Array.Empty();
+ (Expression> Filter, string[] Expected)[] cases =
+ [
+ (r => r.Tags!.Contains("x"), ["match"]),
+ (r => !r.Tags!.Contains("x"), ["null", "empty", "other"]),
+ (r => r.ListTags!.Contains("x"), ["match"]),
+ (r => !r.ListTags!.Contains("x"), ["null", "empty", "other"]),
+ (r => r.Tags!.Any(t => new[] { "x", null }.Contains(t)), ["match"]),
+ (r => !r.Tags!.Any(t => candidates.Contains(t)), ["null", "empty", "other"]),
+ (r => r.ListTags!.Any(t => candidates.Contains(t)), ["match"]),
+ (r => !r.ListTags!.Any(t => candidates.Contains(t)), ["null", "empty", "other"]),
+ (r => r.Tags!.Any(t => nulls.Contains(t)), []),
+ (r => !r.Tags!.Any(t => nulls.Contains(t)), ["null", "empty", "other", "match"]),
+ (r => r.Tags!.Any(t => empty.Contains(t)), []),
+ (r => r.Tags!.Contains(null!), []),
+ (r => !(r.Tags!.Contains("x") && r.ListTags!.Contains("x")), ["null", "empty", "other"]),
+ (r => !(r.Tags!.Contains("x") || r.ListTags!.Contains("x")), ["null", "empty", "other"]),
+ (r => !!r.Tags!.Contains("x"), ["match"]),
+ ];
+ foreach (var (filter, expected) in cases)
+ {
+ var retrieved = await collection.GetAsync(filter, 10).ToListAsync();
+ Assert.Equal(expected.OrderBy(id => id), retrieved.Select(r => r.Id).OrderBy(id => id));
+ var searched = await collection.SearchAsync(new float[] { 1, 0, 0 }, 10,
+ new() { Filter = filter }).ToListAsync();
+ Assert.Equal(expected.OrderBy(id => id), searched.Select(r => r.Record.Id).OrderBy(id => id));
+ }
+ }
+ finally
+ {
+ await collection.EnsureCollectionDeletedAsync();
+ }
+ }
+
+ public sealed class Record
+ {
+ [VectorStoreKey] public string Id { get; set; } = string.Empty;
+ [VectorStoreData(StorageName = "tags")] public string[]? Tags { get; set; }
+ [VectorStoreData] public List? ListTags { get; set; }
+ [VectorStoreVector(3, IndexKind = IndexKind.Flat)] public ReadOnlyMemory Vector { get; set; } = new float[] { 1, 0, 0 };
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusCollectionManagementTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusCollectionManagementTests.cs
new file mode 100644
index 0000000..17812f1
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusCollectionManagementTests.cs
@@ -0,0 +1,14 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.ConformanceTests.Support;
+using VectorData.ConformanceTests;
+using Xunit;
+
+namespace Milvus.ConformanceTests;
+
+public class MilvusCollectionManagementTests(MilvusFixture fixture)
+ : CollectionManagementTests(fixture), IClassFixture
+{
+}
+
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusDatabaseTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusDatabaseTests.cs
new file mode 100644
index 0000000..89dc42f
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusDatabaseTests.cs
@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using CommunityToolkit.VectorData.Milvus;
+using Milvus.ConformanceTests.Support;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.VectorData;
+using Xunit;
+namespace Milvus.ConformanceTests;
+public sealed class MilvusDatabaseTests : IClassFixture
+{
+ [Theory]
+ [InlineData(false)]
+ [InlineData(true)]
+ public async Task HostRegistrationUsesSelectedDatabase(bool apiKey)
+ {
+ var server = MilvusTestStore.Instance;
+ var database = "ct_db_" + Guid.NewGuid().ToString("N");
+ var name = "records_" + Guid.NewGuid().ToString("N");
+ await server.Client.CreateDatabaseAsync(database);
+ try
+ {
+ var services = new ServiceCollection().AddMilvusVectorStore(server.Host, server.Port, database: database,
+ apiKey: apiKey ? "root:Milvus" : null, username: apiKey ? null : "root", password: apiKey ? null : "Milvus");
+ using var provider = services.BuildServiceProvider();
+ var store = provider.GetRequiredService();
+ using var collection = store.GetCollection(name);
+ try
+ {
+ await collection.EnsureCollectionExistsAsync();
+ Assert.True(await collection.CollectionExistsAsync());
+ Assert.False(await server.Client.HasCollectionAsync(name));
+ Assert.Equal(database, Assert.IsType(store.GetService(typeof(VectorStoreMetadata))).VectorStoreName);
+ Assert.Equal(database, Assert.IsType(collection.GetService(typeof(VectorStoreCollectionMetadata))).VectorStoreName);
+ }
+ finally
+ {
+ await collection.EnsureCollectionDeletedAsync();
+ }
+ }
+ finally
+ {
+ await server.Client.DropDatabaseAsync(database);
+ }
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusDependencyInjectionTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusDependencyInjectionTests.cs
new file mode 100644
index 0000000..357c453
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusDependencyInjectionTests.cs
@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using CommunityToolkit.VectorData.Milvus;
+using Milvus.Client;
+using VectorData.ConformanceTests;
+using Xunit;
+
+namespace Milvus.ConformanceTests;
+
+public class MilvusDependencyInjectionTests
+ : DependencyInjectionTests.Record>, long, DependencyInjectionTests.Record>
+{
+ private const string Host = "localhost";
+ private const int Port = 8080;
+ private const string ApiKey = "fakeKey";
+
+ protected override void PopulateConfiguration(ConfigurationManager configuration, object? serviceKey = null)
+ => configuration.AddInMemoryCollection(
+ [
+ new(CreateConfigKey("Milvus", serviceKey, "Host"), Host),
+ new(CreateConfigKey("Milvus", serviceKey, "Port"), Port.ToString()),
+ new(CreateConfigKey("Milvus", serviceKey, "ApiKey"), ApiKey),
+ ]);
+
+ private static string HostProvider(IServiceProvider sp, object? serviceKey = null)
+ => sp.GetRequiredService().GetRequiredSection(CreateConfigKey("Milvus", serviceKey, "Host")).Value!;
+
+ private static int PortProvider(IServiceProvider sp, object? serviceKey = null)
+ => int.Parse(sp.GetRequiredService().GetRequiredSection(CreateConfigKey("Milvus", serviceKey, "Port")).Value!);
+
+ private static string ApiKeyProvider(IServiceProvider sp, object? serviceKey = null)
+ => sp.GetRequiredService().GetRequiredSection(CreateConfigKey("Milvus", serviceKey, "ApiKey")).Value!;
+
+ public override IEnumerable> CollectionDelegates
+ {
+ get
+ {
+ yield return (services, serviceKey, name, lifetime) => serviceKey is null
+ ? services
+ .AddSingleton(sp => new MilvusClient(Host, ApiKey, Port))
+ .AddMilvusCollection(name, lifetime: lifetime)
+ : services
+ .AddSingleton(sp => new MilvusClient(Host, ApiKey, Port))
+ .AddKeyedMilvusCollection(serviceKey, name, lifetime: lifetime);
+
+ yield return (services, serviceKey, name, lifetime) => serviceKey is null
+ ? services.AddMilvusCollection(
+ name, Host, Port, apiKey: ApiKey, lifetime: lifetime)
+ : services.AddKeyedMilvusCollection(
+ serviceKey, name, Host, Port, apiKey: ApiKey, lifetime: lifetime);
+
+ yield return (services, serviceKey, name, lifetime) => serviceKey is null
+ ? services.AddMilvusCollection(
+ name, sp => new MilvusClient(HostProvider(sp), ApiKeyProvider(sp), PortProvider(sp)), lifetime: lifetime)
+ : services.AddKeyedMilvusCollection(
+ serviceKey, name, sp => new MilvusClient(HostProvider(sp, serviceKey), ApiKeyProvider(sp, serviceKey), PortProvider(sp, serviceKey)), lifetime: lifetime);
+ }
+ }
+
+ public override IEnumerable> StoreDelegates
+ {
+ get
+ {
+ yield return (services, serviceKey, lifetime) => serviceKey is null
+ ? services.AddMilvusVectorStore(
+ Host, Port, apiKey: ApiKey, lifetime: lifetime)
+ : services.AddKeyedMilvusVectorStore(
+ serviceKey, Host, Port, apiKey: ApiKey, lifetime: lifetime);
+
+ yield return (services, serviceKey, lifetime) => serviceKey is null
+ ? services
+ .AddSingleton(sp => new MilvusClient(Host, ApiKey, Port))
+ .AddMilvusVectorStore(lifetime: lifetime)
+ : services
+ .AddSingleton(sp => new MilvusClient(Host, ApiKey, Port))
+ .AddKeyedMilvusVectorStore(serviceKey, lifetime: lifetime);
+ }
+ }
+
+ [Fact]
+ public void HostCantBeNullOrEmpty()
+ {
+ IServiceCollection services = new ServiceCollection();
+
+ Assert.Throws(() => services.AddMilvusVectorStore(host: null!));
+ Assert.Throws(() => services.AddKeyedMilvusVectorStore(serviceKey: "notNull", host: null!));
+ Assert.Throws(() => services.AddMilvusCollection(
+ name: "notNull", host: null!));
+ Assert.Throws(() => services.AddMilvusCollection(
+ name: "notNull", host: ""));
+ Assert.Throws(() => services.AddKeyedMilvusCollection(
+ serviceKey: "notNull", name: "notNull", host: null!));
+ Assert.Throws(() => services.AddKeyedMilvusCollection(
+ serviceKey: "notNull", name: "notNull", host: ""));
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusDistanceFunctionTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusDistanceFunctionTests.cs
new file mode 100644
index 0000000..071ea79
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusDistanceFunctionTests.cs
@@ -0,0 +1,19 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.ConformanceTests.Support;
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Xunit;
+namespace Milvus.ConformanceTests;
+public class MilvusDistanceFunctionTests(MilvusDistanceFunctionTests.Fixture fixture) : DistanceFunctionTests(fixture), IClassFixture
+{
+ public override Task NegativeDotProductSimilarity() => Assert.ThrowsAsync(base.NegativeDotProductSimilarity);
+ public override Task ManhattanDistance() => Assert.ThrowsAsync(base.ManhattanDistance);
+ public override Task HammingDistance() => Assert.ThrowsAsync(base.HammingDistance);
+ public override Task CosineDistance() => Assert.ThrowsAsync(base.CosineDistance);
+ public new class Fixture : DistanceFunctionTests.Fixture
+ {
+ public override TestStore TestStore => MilvusTestStore.Instance;
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusEmbeddingGenerationTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusEmbeddingGenerationTests.cs
new file mode 100644
index 0000000..73472e3
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusEmbeddingGenerationTests.cs
@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Milvus.ConformanceTests.Support;
+using Milvus.Client;
+using CommunityToolkit.VectorData.Milvus;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.VectorData;
+using VectorData.ConformanceTests;
+using VectorData.ConformanceTests.Support;
+using Xunit;
+
+namespace Milvus.ConformanceTests;
+
+public class MilvusEmbeddingGenerationTests(MilvusEmbeddingGenerationTests.StringVectorFixture stringVectorFixture, MilvusEmbeddingGenerationTests.RomOfFloatVectorFixture romOfFloatVectorFixture)
+ : EmbeddingGenerationTests(stringVectorFixture, romOfFloatVectorFixture), IClassFixture, IClassFixture
+{
+ public new class StringVectorFixture : EmbeddingGenerationTests.StringVectorFixture
+ {
+ public override TestStore TestStore => MilvusTestStore.Instance;
+
+ public override VectorStore CreateVectorStore(IEmbeddingGenerator? embeddingGenerator)
+ => MilvusTestStore.Instance.GetVectorStore(new() { EmbeddingGenerator = embeddingGenerator });
+
+ public override Func[] DependencyInjectionStoreRegistrationDelegates =>
+ [
+ services => services
+ .AddSingleton(MilvusTestStore.Instance.Client)
+ .AddMilvusVectorStore()
+ ];
+
+ public override Func[] DependencyInjectionCollectionRegistrationDelegates =>
+ [
+ services => services
+ .AddSingleton(MilvusTestStore.Instance.Client)
+ .AddMilvusCollection(this.CollectionName)
+ ];
+ }
+
+ public new class RomOfFloatVectorFixture : EmbeddingGenerationTests.RomOfFloatVectorFixture
+ {
+ public override TestStore TestStore => MilvusTestStore.Instance;
+
+ public override VectorStore CreateVectorStore(IEmbeddingGenerator? embeddingGenerator)
+ => MilvusTestStore.Instance.GetVectorStore(new() { EmbeddingGenerator = embeddingGenerator });
+
+ public override Func[] DependencyInjectionStoreRegistrationDelegates =>
+ [
+ services => services
+ .AddSingleton(MilvusTestStore.Instance.Client)
+ .AddMilvusVectorStore()
+ ];
+
+ public override Func[] DependencyInjectionCollectionRegistrationDelegates =>
+ [
+ services => services
+ .AddSingleton(MilvusTestStore.Instance.Client)
+ .AddMilvusCollection(this.CollectionName)
+ ];
+ }
+}
diff --git a/MEVD/test/Milvus.ConformanceTests/MilvusEnsureCollectionTests.cs b/MEVD/test/Milvus.ConformanceTests/MilvusEnsureCollectionTests.cs
new file mode 100644
index 0000000..a0a4193
--- /dev/null
+++ b/MEVD/test/Milvus.ConformanceTests/MilvusEnsureCollectionTests.cs
@@ -0,0 +1,87 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using CommunityToolkit.VectorData.Milvus;
+using Microsoft.Extensions.VectorData;
+using Milvus.Client;
+using Milvus.ConformanceTests.Support;
+using Xunit;
+
+namespace Milvus.ConformanceTests;
+
+public sealed class MilvusEnsureCollectionTests : IClassFixture
+{
+ [Fact]
+ public async Task EnsureCollectionExistsKeepsTheIndexOfAnExistingCollection()
+ {
+ // The collection exists with an HNSW index, where the model asks for a Flat one: as another tool could create it.
+ var client = MilvusTestStore.Instance.Client;
+ var name = "ct_existing_index_" + Guid.NewGuid().ToString("N");
+ await client.CreateCollectionAsync(name,
+ [FieldSchema.CreateVarchar("Id", 65535, isPrimaryKey: true), FieldSchema.CreateVarchar("Text", 65535, nullable: true), FieldSchema.CreateFloatVector("Vector", 3)]);
+ var records = client.GetCollection(name);
+ await records.CreateIndexAsync("Vector", IndexType.Hnsw, SimilarityMetricType.Cosine,
+ extraParams: new Dictionary { ["M"] = "8", ["efConstruction"] = "64" });
+ using var collection = new MilvusCollection(client, name, ownsClient: false);
+ try
+ {
+ await collection.EnsureCollectionExistsAsync();
+ await collection.UpsertAsync(new Record { Id = "a", Text = "apples", Vector = new float[] { 1, 0, 0 } });
+
+ Assert.Equal("a", Assert.Single(await collection.SearchAsync(new float[] { 1, 0, 0 }, 1).ToListAsync()).Record.Id);
+ Assert.Contains(Assert.Single(await records.DescribeIndexAsync("Vector")).Params, p => p.Value == "HNSW");
+ }
+ finally
+ {
+ await collection.EnsureCollectionDeletedAsync();
+ }
+ }
+
+ [Fact]
+ public async Task EnsureCollectionExistsAcceptsAnExistingCollectionWithoutTheBm25Field()
+ {
+ // The collection was created before the text property was full-text indexed: it has no BM25 field.
+ var client = MilvusTestStore.Instance.Client;
+ var name = "ct_existing_text_" + Guid.NewGuid().ToString("N");
+ using (var before = new MilvusCollection(client, name, ownsClient: false))
+ {
+ await before.EnsureCollectionExistsAsync();
+ }
+ using var collection = new MilvusCollection(client, name, ownsClient: false);
+ try
+ {
+ await collection.EnsureCollectionExistsAsync();
+ await collection.UpsertAsync(new FullTextRecord { Id = "a", Text = "apples", Vector = new float[] { 1, 0, 0 } });
+
+ Assert.Equal("a", Assert.Single(await collection.SearchAsync(new float[] { 1, 0, 0 }, 1).ToListAsync()).Record.Id);
+ }
+ finally
+ {
+ await collection.EnsureCollectionDeletedAsync();
+ }
+ }
+
+ public sealed class Record
+ {
+ [VectorStoreKey]
+ public string Id { get; set; } = string.Empty;
+
+ [VectorStoreData]
+ public string? Text { get; set; }
+
+ [VectorStoreVector(3, IndexKind = IndexKind.Flat)]
+ public ReadOnlyMemory Vector { get; set; }
+ }
+
+ public sealed class FullTextRecord
+ {
+ [VectorStoreKey]
+ public string Id { get; set; } = string.Empty;
+
+ [VectorStoreData(IsFullTextIndexed = true)]
+ public string? Text { get; set; }
+
+ [VectorStoreVector(3, IndexKind = IndexKind.Flat)]
+ public ReadOnlyMemory