From 057ad3f9725a8e94a5ada8025c417b7138e7d4d3 Mon Sep 17 00:00:00 2001
From: Dmytro Struk <13853051+dmytrostruk@users.noreply.github.com>
Date: Tue, 15 Apr 2025 14:12:36 -0700
Subject: [PATCH 1/2] Added extension methods of GetRequiredService

---
 .../VectorData.Abstractions/Throw.cs          | 14 ++++++++
 .../KeywordHybridSearchExtensions.cs          | 33 +++++++++++++++++++
 .../VectorizableTextSearchExtensions.cs       | 33 +++++++++++++++++++
 .../VectorizedSearchExtensions.cs             | 33 +++++++++++++++++++
 .../VectorStorage/VectorStoreExtensions.cs    | 33 +++++++++++++++++++
 5 files changed, 146 insertions(+)
 create mode 100644 dotnet/src/Connectors/VectorData.Abstractions/Throw.cs
 create mode 100644 dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/KeywordHybridSearchExtensions.cs
 create mode 100644 dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizableTextSearchExtensions.cs
 create mode 100644 dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizedSearchExtensions.cs
 create mode 100644 dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/VectorStoreExtensions.cs

diff --git a/dotnet/src/Connectors/VectorData.Abstractions/Throw.cs b/dotnet/src/Connectors/VectorData.Abstractions/Throw.cs
new file mode 100644
index 000000000000..42682c708155
--- /dev/null
+++ b/dotnet/src/Connectors/VectorData.Abstractions/Throw.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+
+namespace Microsoft.Extensions.VectorData;
+
+internal static class Throw
+{
+    /// <summary>Throws an exception indicating that a required service is not available.</summary>
+    public static InvalidOperationException CreateMissingServiceException(Type serviceType, object? serviceKey) =>
+        new(serviceKey is null ?
+            $"No service of type '{serviceType}' is available." :
+            $"No service of type '{serviceType}' for the key '{serviceKey}' is available.");
+}
diff --git a/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/KeywordHybridSearchExtensions.cs b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/KeywordHybridSearchExtensions.cs
new file mode 100644
index 000000000000..0e8435ae25c2
--- /dev/null
+++ b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/KeywordHybridSearchExtensions.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.Extensions.VectorData;
+
+/// <summary>Provides a collection of static methods for extending <see cref="IKeywordHybridSearch{TRecord}"/> instances.</summary>
+[Experimental("MEVD9000")]
+public static class KeywordHybridSearchExtensions
+{
+    /// <summary>
+    /// Asks the <see cref="IKeywordHybridSearch{TRecord}"/> for an object of the specified type <paramref name="serviceType"/>
+    /// and throw an exception if one isn't available.
+    /// </summary>
+    /// <typeparam name="TRecord">The record data model to use for retrieving data from the store.</typeparam>
+    /// <param name="keywordHybridSearch">The keyword hybrid search.</param>
+    /// <param name="serviceType">The type of object being requested.</param>
+    /// <param name="serviceKey">An optional key that can be used to help identify the target service.</param>
+    /// <returns>The found object.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="keywordHybridSearch"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">No service of the requested type for the specified key is available.</exception>
+    public static object GetRequiredService<TRecord>(this IKeywordHybridSearch<TRecord> keywordHybridSearch, Type serviceType, object? serviceKey = null)
+    {
+        if (keywordHybridSearch is null) { throw new ArgumentNullException(nameof(keywordHybridSearch)); }
+        if (serviceType is null) { throw new ArgumentNullException(nameof(serviceType)); }
+
+        return
+            keywordHybridSearch.GetService(serviceType, serviceKey) ??
+            throw Throw.CreateMissingServiceException(serviceType, serviceKey);
+    }
+}
diff --git a/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizableTextSearchExtensions.cs b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizableTextSearchExtensions.cs
new file mode 100644
index 000000000000..442155bdcccc
--- /dev/null
+++ b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizableTextSearchExtensions.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.Extensions.VectorData;
+
+/// <summary>Provides a collection of static methods for extending <see cref="IVectorizableTextSearch{TRecord}"/> instances.</summary>
+[Experimental("MEVD9000")]
+public static class VectorizableTextSearchExtensions
+{
+    /// <summary>
+    /// Asks the <see cref="IVectorizableTextSearch{TRecord}"/> for an object of the specified type <paramref name="serviceType"/>
+    /// and throw an exception if one isn't available.
+    /// </summary>
+    /// <typeparam name="TRecord">The record data model to use for retrieving data from the store.</typeparam>
+    /// <param name="vectorizableTextSearch">The vectorizable text search.</param>
+    /// <param name="serviceType">The type of object being requested.</param>
+    /// <param name="serviceKey">An optional key that can be used to help identify the target service.</param>
+    /// <returns>The found object.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="vectorizableTextSearch"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">No service of the requested type for the specified key is available.</exception>
+    public static object GetRequiredService<TRecord>(this IVectorizableTextSearch<TRecord> vectorizableTextSearch, Type serviceType, object? serviceKey = null)
+    {
+        if (vectorizableTextSearch is null) { throw new ArgumentNullException(nameof(vectorizableTextSearch)); }
+        if (serviceType is null) { throw new ArgumentNullException(nameof(serviceType)); }
+
+        return
+            vectorizableTextSearch.GetService(serviceType, serviceKey) ??
+            throw Throw.CreateMissingServiceException(serviceType, serviceKey);
+    }
+}
diff --git a/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizedSearchExtensions.cs b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizedSearchExtensions.cs
new file mode 100644
index 000000000000..07b40aa39b21
--- /dev/null
+++ b/dotnet/src/Connectors/VectorData.Abstractions/VectorSearch/VectorizedSearchExtensions.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.Extensions.VectorData;
+
+/// <summary>Provides a collection of static methods for extending <see cref="IVectorizedSearch{TRecord}"/> instances.</summary>
+[Experimental("MEVD9000")]
+public static class VectorizedSearchExtensions
+{
+    /// <summary>
+    /// Asks the <see cref="IVectorizedSearch{TRecord}"/> for an object of the specified type <paramref name="serviceType"/>
+    /// and throw an exception if one isn't available.
+    /// </summary>
+    /// <typeparam name="TRecord">The record data model to use for retrieving data from the store.</typeparam>
+    /// <param name="vectorizedSearch">The vectorized search.</param>
+    /// <param name="serviceType">The type of object being requested.</param>
+    /// <param name="serviceKey">An optional key that can be used to help identify the target service.</param>
+    /// <returns>The found object.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="vectorizedSearch"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">No service of the requested type for the specified key is available.</exception>
+    public static object GetRequiredService<TRecord>(this IVectorizedSearch<TRecord> vectorizedSearch, Type serviceType, object? serviceKey = null)
+    {
+        if (vectorizedSearch is null) { throw new ArgumentNullException(nameof(vectorizedSearch)); }
+        if (serviceType is null) { throw new ArgumentNullException(nameof(serviceType)); }
+
+        return
+            vectorizedSearch.GetService(serviceType, serviceKey) ??
+            throw Throw.CreateMissingServiceException(serviceType, serviceKey);
+    }
+}
diff --git a/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/VectorStoreExtensions.cs b/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/VectorStoreExtensions.cs
new file mode 100644
index 000000000000..9d50678cc118
--- /dev/null
+++ b/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/VectorStoreExtensions.cs
@@ -0,0 +1,33 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Microsoft.Extensions.VectorData;
+
+/// <summary>Provides a collection of static methods for extending <see cref="IVectorStore"/> instances.</summary>
+[Experimental("MEVD9000")]
+public static class VectorStoreExtensions
+{
+    /// <summary>
+    /// Asks the <see cref="IVectorStore"/> for an object of the specified type <paramref name="serviceType"/>
+    /// and throw an exception if one isn't available.
+    /// </summary>
+    /// <typeparam name="TRecord">The record data model to use for retrieving data from the store.</typeparam>
+    /// <param name="vectorStore">The vector store.</param>
+    /// <param name="serviceType">The type of object being requested.</param>
+    /// <param name="serviceKey">An optional key that can be used to help identify the target service.</param>
+    /// <returns>The found object.</returns>
+    /// <exception cref="ArgumentNullException"><paramref name="vectorStore"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="serviceType"/> is <see langword="null"/>.</exception>
+    /// <exception cref="InvalidOperationException">No service of the requested type for the specified key is available.</exception>
+    public static object GetRequiredService<TRecord>(this IVectorStore vectorStore, Type serviceType, object? serviceKey = null)
+    {
+        if (vectorStore is null) { throw new ArgumentNullException(nameof(vectorStore)); }
+        if (serviceType is null) { throw new ArgumentNullException(nameof(serviceType)); }
+
+        return
+            vectorStore.GetService(serviceType, serviceKey) ??
+            throw Throw.CreateMissingServiceException(serviceType, serviceKey);
+    }
+}

From cb4c52dfc5ea8f7c17db1c8a35cef5927d033887 Mon Sep 17 00:00:00 2001
From: Dmytro Struk <13853051+dmytrostruk@users.noreply.github.com>
Date: Tue, 15 Apr 2025 14:39:04 -0700
Subject: [PATCH 2/2] Renamed CollectionName to Name

---
 ...extEmbeddingVectorStoreRecordCollection.cs |  2 +-
 ...zureAISearchVectorStoreRecordCollection.cs | 14 ++---
 ...mosDBMongoDBVectorStoreRecordCollection.cs | 38 ++++++------
 ...osmosDBNoSQLVectorStoreRecordCollection.cs | 36 +++++------
 .../InMemoryVectorStoreRecordCollection.cs    | 14 ++---
 .../MongoDBVectorStoreRecordCollection.cs     | 44 ++++++-------
 .../PineconeVectorStoreRecordCollection.cs    | 38 ++++++------
 .../PostgresVectorStoreRecordCollection.cs    | 62 +++++++++----------
 .../QdrantVectorStoreRecordCollection.cs      | 24 +++----
 ...RedisHashSetVectorStoreRecordCollection.cs | 12 ++--
 .../RedisJsonVectorStoreRecordCollection.cs   | 12 ++--
 .../SqlServerVectorStoreRecordCollection.cs   | 52 ++++++++--------
 .../SqliteVectorStoreRecordCollection.cs      | 22 +++----
 .../WeaviateVectorStoreRecordCollection.cs    | 46 +++++++-------
 .../IVectorStoreRecordCollection.cs           |  2 +-
 15 files changed, 209 insertions(+), 209 deletions(-)

diff --git a/dotnet/samples/Concepts/Memory/VectorStoreEmbeddingGeneration/TextEmbeddingVectorStoreRecordCollection.cs b/dotnet/samples/Concepts/Memory/VectorStoreEmbeddingGeneration/TextEmbeddingVectorStoreRecordCollection.cs
index d3ae50ec7130..eaf346e90020 100644
--- a/dotnet/samples/Concepts/Memory/VectorStoreEmbeddingGeneration/TextEmbeddingVectorStoreRecordCollection.cs
+++ b/dotnet/samples/Concepts/Memory/VectorStoreEmbeddingGeneration/TextEmbeddingVectorStoreRecordCollection.cs
@@ -49,7 +49,7 @@ public TextEmbeddingVectorStoreRecordCollection(IVectorStoreRecordCollection<TKe
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._decoratedVectorStoreRecordCollection.CollectionName;
+    public string Name => this._decoratedVectorStoreRecordCollection.Name;
 
     /// <inheritdoc />
     public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
diff --git a/dotnet/src/Connectors/Connectors.Memory.AzureAISearch/AzureAISearchVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.AzureAISearch/AzureAISearchVectorStoreRecordCollection.cs
index 60a5e26e320f..711467eb1ba2 100644
--- a/dotnet/src/Connectors/Connectors.Memory.AzureAISearch/AzureAISearchVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.AzureAISearch/AzureAISearchVectorStoreRecordCollection.cs
@@ -64,15 +64,15 @@ public sealed class AzureAISearchVectorStoreRecordCollection<TKey, TRecord> :
     /// Initializes a new instance of the <see cref="AzureAISearchVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="searchIndexClient">Azure AI Search client that can be used to manage the list of indices in an Azure AI Search Service.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="AzureAISearchVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="AzureAISearchVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="searchIndexClient"/> is null.</exception>
     /// <exception cref="ArgumentException">Thrown when options are misconfigured.</exception>
-    public AzureAISearchVectorStoreRecordCollection(SearchIndexClient searchIndexClient, string collectionName, AzureAISearchVectorStoreRecordCollectionOptions<TRecord>? options = default)
+    public AzureAISearchVectorStoreRecordCollection(SearchIndexClient searchIndexClient, string name, AzureAISearchVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(searchIndexClient);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -81,9 +81,9 @@ public AzureAISearchVectorStoreRecordCollection(SearchIndexClient searchIndexCli
 
         // Assign.
         this._searchIndexClient = searchIndexClient;
-        this._collectionName = collectionName;
+        this._collectionName = name;
         this._options = options ?? new AzureAISearchVectorStoreRecordCollectionOptions<TRecord>();
-        this._searchClient = this._searchIndexClient.GetSearchClient(collectionName);
+        this._searchClient = this._searchIndexClient.GetSearchClient(name);
 
         this._model = new VectorStoreRecordJsonModelBuilder(AzureAISearchConstants.s_modelBuildingOptions)
             .Build(typeof(TRecord), this._options.VectorStoreRecordDefinition, this._options.JsonSerializerOptions);
@@ -100,12 +100,12 @@ public AzureAISearchVectorStoreRecordCollection(SearchIndexClient searchIndexCli
         {
             VectorStoreSystemName = AzureAISearchConstants.VectorStoreSystemName,
             VectorStoreName = searchIndexClient.ServiceName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._collectionName;
+    public string Name => this._collectionName;
 
     /// <inheritdoc />
     public async Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
diff --git a/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBMongoDB/AzureCosmosDBMongoDBVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBMongoDB/AzureCosmosDBMongoDBVectorStoreRecordCollection.cs
index c9cdc5a9c7d5..77ab871771c9 100644
--- a/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBMongoDB/AzureCosmosDBMongoDBVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBMongoDB/AzureCosmosDBMongoDBVectorStoreRecordCollection.cs
@@ -58,22 +58,22 @@ public sealed class AzureCosmosDBMongoDBVectorStoreRecordCollection<TKey, TRecor
     private readonly VectorStoreRecordModel _model;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AzureCosmosDBMongoDBVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="mongoDatabase"><see cref="IMongoDatabase"/> that can be used to manage the collections in Azure CosmosDB MongoDB.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="AzureCosmosDBMongoDBVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="AzureCosmosDBMongoDBVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     public AzureCosmosDBMongoDBVectorStoreRecordCollection(
         IMongoDatabase mongoDatabase,
-        string collectionName,
+        string name,
         AzureCosmosDBMongoDBVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(mongoDatabase);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -82,8 +82,8 @@ public AzureCosmosDBMongoDBVectorStoreRecordCollection(
 
         // Assign.
         this._mongoDatabase = mongoDatabase;
-        this._mongoCollection = mongoDatabase.GetCollection<BsonDocument>(collectionName);
-        this.CollectionName = collectionName;
+        this._mongoCollection = mongoDatabase.GetCollection<BsonDocument>(name);
+        this.Name = name;
         this._options = options ?? new AzureCosmosDBMongoDBVectorStoreRecordCollectionOptions<TRecord>();
         this._model = new MongoDBModelBuilder().Build(typeof(TRecord), this._options.VectorStoreRecordDefinition);
         this._mapper = typeof(TRecord) == typeof(Dictionary<string, object?>)
@@ -94,7 +94,7 @@ public AzureCosmosDBMongoDBVectorStoreRecordCollection(
         {
             VectorStoreSystemName = AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
             VectorStoreName = mongoDatabase.DatabaseNamespace?.DatabaseName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -113,7 +113,7 @@ public async Task CreateCollectionAsync(CancellationToken cancellationToken = de
             {
                 VectorStoreSystemName = AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = "CreateCollection"
             };
         }
@@ -125,10 +125,10 @@ public async Task CreateCollectionAsync(CancellationToken cancellationToken = de
     public async Task CreateCollectionIfNotExistsAsync(CancellationToken cancellationToken = default)
     {
         await this.RunOperationAsync("CreateCollection",
-            () => this._mongoDatabase.CreateCollectionAsync(this.CollectionName, cancellationToken: cancellationToken)).ConfigureAwait(false);
+            () => this._mongoDatabase.CreateCollectionAsync(this.Name, cancellationToken: cancellationToken)).ConfigureAwait(false);
 
         await this.RunOperationAsync("CreateIndexes",
-            () => this.CreateIndexesAsync(this.CollectionName, cancellationToken: cancellationToken)).ConfigureAwait(false);
+            () => this.CreateIndexesAsync(this.Name, cancellationToken: cancellationToken)).ConfigureAwait(false);
     }
 
     /// <inheritdoc />
@@ -153,7 +153,7 @@ await this.RunOperationAsync("DeleteMany", () => this._mongoCollection.DeleteMan
 
     /// <inheritdoc />
     public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
-        => this.RunOperationAsync("DropCollection", () => this._mongoDatabase.DropCollectionAsync(this.CollectionName, cancellationToken));
+        => this.RunOperationAsync("DropCollection", () => this._mongoDatabase.DropCollectionAsync(this.Name, cancellationToken));
 
     /// <inheritdoc />
     public async Task<TRecord?> GetAsync(TKey key, GetRecordOptions? options = null, CancellationToken cancellationToken = default)
@@ -181,7 +181,7 @@ public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
         return VectorStoreErrorHandler.RunModelConversion(
             AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromStorageToDataModel(record, new() { IncludeVectors = includeVectors }));
     }
@@ -211,7 +211,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(
                     yield return VectorStoreErrorHandler.RunModelConversion(
                         AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(record, new()));
                 }
@@ -230,7 +230,7 @@ public Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellationToke
         var storageModel = VectorStoreErrorHandler.RunModelConversion(
             AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -391,7 +391,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
                 var record = VectorStoreErrorHandler.RunModelConversion(
                     AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                     this._collectionMetadata.VectorStoreName,
-                    this.CollectionName,
+                    this.Name,
                     "GetAsync",
                     () => this._mapper.MapFromStorageToDataModel(response, new() { IncludeVectors = options.IncludeVectors }));
 
@@ -475,7 +475,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> EnumerateAndMapSearc
                     var record = VectorStoreErrorHandler.RunModelConversion(
                         AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(response[DocumentPropertyName].AsBsonDocument, new()));
 
@@ -495,7 +495,7 @@ private FilterDefinition<BsonDocument> GetFilterByIds(IEnumerable<string> ids)
 
     private async Task<bool> InternalCollectionExistsAsync(CancellationToken cancellationToken)
     {
-        var filter = new BsonDocument("name", this.CollectionName);
+        var filter = new BsonDocument("name", this.Name);
         var options = new ListCollectionNamesOptions { Filter = filter };
 
         using var cursor = await this._mongoDatabase.ListCollectionNamesAsync(options, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -515,7 +515,7 @@ private async Task RunOperationAsync(string operationName, Func<Task> operation)
             {
                 VectorStoreSystemName = AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -533,7 +533,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = AzureCosmosDBMongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
diff --git a/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBNoSQL/AzureCosmosDBNoSQLVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBNoSQL/AzureCosmosDBNoSQLVectorStoreRecordCollection.cs
index fff3d2fd5a56..b61112ff5439 100644
--- a/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBNoSQL/AzureCosmosDBNoSQLVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.AzureCosmosDBNoSQL/AzureCosmosDBNoSQLVectorStoreRecordCollection.cs
@@ -57,22 +57,22 @@ public sealed class AzureCosmosDBNoSQLVectorStoreRecordCollection<TKey, TRecord>
     private readonly ICosmosNoSQLMapper<TRecord> _mapper;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="AzureCosmosDBNoSQLVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="database"><see cref="Database"/> that can be used to manage the collections in Azure CosmosDB NoSQL.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="AzureCosmosDBNoSQLVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="AzureCosmosDBNoSQLVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     public AzureCosmosDBNoSQLVectorStoreRecordCollection(
         Database database,
-        string collectionName,
+        string name,
         AzureCosmosDBNoSQLVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(database);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(AzureCosmosDBNoSQLCompositeKey) && typeof(TKey) != typeof(object))
         {
@@ -88,7 +88,7 @@ public AzureCosmosDBNoSQLVectorStoreRecordCollection(
 
         // Assign.
         this._database = database;
-        this.CollectionName = collectionName;
+        this.Name = name;
         this._options = options ?? new();
         var jsonSerializerOptions = this._options.JsonSerializerOptions ?? JsonSerializerOptions.Default;
         this._model = new AzureCosmosDBNoSqlVectorStoreModelBuilder()
@@ -124,7 +124,7 @@ public AzureCosmosDBNoSQLVectorStoreRecordCollection(
         {
             VectorStoreSystemName = AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
             VectorStoreName = database.Id,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -135,7 +135,7 @@ public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = de
         {
             const string Query = "SELECT VALUE(c.id) FROM c WHERE c.id = @collectionName";
 
-            var queryDefinition = new QueryDefinition(Query).WithParameter("@collectionName", this.CollectionName);
+            var queryDefinition = new QueryDefinition(Query).WithParameter("@collectionName", this.Name);
 
             using var feedIterator = this._database.GetContainerQueryIterator<string>(queryDefinition);
 
@@ -174,7 +174,7 @@ public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
     {
         return this.RunOperationAsync("DeleteContainer", () =>
             this._database
-                .GetContainer(this.CollectionName)
+                .GetContainer(this.Name)
                 .DeleteContainerAsync(cancellationToken: cancellationToken));
     }
 
@@ -194,7 +194,7 @@ public async Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancella
 
             return this.RunOperationAsync("DeleteItem", () =>
                 this._database
-                    .GetContainer(this.CollectionName)
+                    .GetContainer(this.Name)
                     .DeleteItemAsync<JsonObject>(key.RecordKey, new PartitionKey(key.PartitionKey), cancellationToken: cancellationToken));
         });
 
@@ -233,7 +233,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(
             var record = VectorStoreErrorHandler.RunModelConversion(
                 AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 OperationName,
                 () => this._mapper.MapFromStorageToDataModel(jsonObject, new() { IncludeVectors = includeVectors }));
 
@@ -254,7 +254,7 @@ public async Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellati
         var jsonObject = VectorStoreErrorHandler.RunModelConversion(
                 AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 OperationName,
                 () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -273,7 +273,7 @@ public async Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellati
 
         await this.RunOperationAsync(OperationName, () =>
             this._database
-                .GetContainer(this.CollectionName)
+                .GetContainer(this.Name)
                 .UpsertItemAsync(jsonObject, new PartitionKey(partitionKeyValue), cancellationToken: cancellationToken))
             .ConfigureAwait(false);
 
@@ -361,7 +361,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
             var record = VectorStoreErrorHandler.RunModelConversion(
                 AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 "GetAsync",
                 () => this._mapper.MapFromStorageToDataModel(jsonObject, new() { IncludeVectors = options.IncludeVectors }));
 
@@ -447,7 +447,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -471,7 +471,7 @@ private ContainerProperties GetContainerProperties()
 
         if (this._options.IndexingMode == IndexingMode.None)
         {
-            return new ContainerProperties(this.CollectionName, partitionKeyPath: $"/{this._partitionKeyProperty.StorageName}")
+            return new ContainerProperties(this.Name, partitionKeyPath: $"/{this._partitionKeyProperty.StorageName}")
             {
                 IndexingPolicy = indexingPolicy
             };
@@ -528,7 +528,7 @@ private ContainerProperties GetContainerProperties()
             indexingPolicy.ExcludedPaths.Add(new ExcludedPath { Path = $"{vectorIndexPath.Path}/*" });
         }
 
-        return new ContainerProperties(this.CollectionName, partitionKeyPath: $"/{this._partitionKeyProperty.StorageName}")
+        return new ContainerProperties(this.Name, partitionKeyPath: $"/{this._partitionKeyProperty.StorageName}")
         {
             VectorEmbeddingPolicy = vectorEmbeddingPolicy,
             IndexingPolicy = indexingPolicy,
@@ -583,7 +583,7 @@ private static VectorDataType GetDataType(Type vectorDataType, string vectorProp
     private async IAsyncEnumerable<T> GetItemsAsync<T>(QueryDefinition queryDefinition, [EnumeratorCancellation] CancellationToken cancellationToken)
     {
         var iterator = this._database
-            .GetContainer(this.CollectionName)
+            .GetContainer(this.Name)
             .GetItemQueryIterator<T>(queryDefinition);
 
         while (iterator.HasMoreResults)
@@ -617,7 +617,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> MapSearchResultsAsyn
             var record = VectorStoreErrorHandler.RunModelConversion(
                 AzureCosmosDBNoSQLConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 operationName,
                 () => this._mapper.MapFromStorageToDataModel(jsonObject, new() { IncludeVectors = includeVectors }));
 
diff --git a/dotnet/src/Connectors/Connectors.Memory.InMemory/InMemoryVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.InMemory/InMemoryVectorStoreRecordCollection.cs
index 419996e7bc00..810f9932245b 100644
--- a/dotnet/src/Connectors/Connectors.Memory.InMemory/InMemoryVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.InMemory/InMemoryVectorStoreRecordCollection.cs
@@ -67,15 +67,15 @@ public sealed class InMemoryVectorStoreRecordCollection<TKey, TRecord> : IVector
     /// <summary>
     /// Initializes a new instance of the <see cref="InMemoryVectorStoreRecordCollection{TKey,TRecord}"/> class.
     /// </summary>
-    /// <param name="collectionName">The name of the collection that this <see cref="InMemoryVectorStoreRecordCollection{TKey,TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="InMemoryVectorStoreRecordCollection{TKey,TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
-    public InMemoryVectorStoreRecordCollection(string collectionName, InMemoryVectorStoreRecordCollectionOptions<TKey, TRecord>? options = default)
+    public InMemoryVectorStoreRecordCollection(string name, InMemoryVectorStoreRecordCollectionOptions<TKey, TRecord>? options = default)
     {
         // Verify.
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         // Assign.
-        this._collectionName = collectionName;
+        this._collectionName = name;
         this._internalCollections = new();
         this._internalCollectionTypes = new();
         this._options = options ?? new InMemoryVectorStoreRecordCollectionOptions<TKey, TRecord>();
@@ -111,7 +111,7 @@ public InMemoryVectorStoreRecordCollection(string collectionName, InMemoryVector
         this._collectionMetadata = new()
         {
             VectorStoreSystemName = InMemoryConstants.VectorStoreSystemName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -134,7 +134,7 @@ internal InMemoryVectorStoreRecordCollection(
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._collectionName;
+    public string Name => this._collectionName;
 
     /// <inheritdoc />
     public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
@@ -155,7 +155,7 @@ public Task CreateCollectionAsync(CancellationToken cancellationToken = default)
         return Task.FromException(new VectorStoreOperationException("Collection already exists.")
         {
             VectorStoreSystemName = InMemoryConstants.VectorStoreSystemName,
-            CollectionName = this.CollectionName,
+            CollectionName = this.Name,
             OperationName = "CreateCollection"
         });
     }
diff --git a/dotnet/src/Connectors/Connectors.Memory.MongoDB/MongoDBVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.MongoDB/MongoDBVectorStoreRecordCollection.cs
index 38244c4292a1..7ed0a3cc0b45 100644
--- a/dotnet/src/Connectors/Connectors.Memory.MongoDB/MongoDBVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.MongoDB/MongoDBVectorStoreRecordCollection.cs
@@ -58,22 +58,22 @@ public sealed class MongoDBVectorStoreRecordCollection<TKey, TRecord> : IVectorS
     private readonly VectorStoreRecordModel _model;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="MongoDBVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="mongoDatabase"><see cref="IMongoDatabase"/> that can be used to manage the collections in MongoDB.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="MongoDBVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="MongoDBVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     public MongoDBVectorStoreRecordCollection(
         IMongoDatabase mongoDatabase,
-        string collectionName,
+        string name,
         MongoDBVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(mongoDatabase);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -82,8 +82,8 @@ public MongoDBVectorStoreRecordCollection(
 
         // Assign.
         this._mongoDatabase = mongoDatabase;
-        this._mongoCollection = mongoDatabase.GetCollection<BsonDocument>(collectionName);
-        this.CollectionName = collectionName;
+        this._mongoCollection = mongoDatabase.GetCollection<BsonDocument>(name);
+        this.Name = name;
         this._options = options ?? new MongoDBVectorStoreRecordCollectionOptions<TRecord>();
         this._model = new MongoDBModelBuilder().Build(typeof(TRecord), this._options.VectorStoreRecordDefinition);
         this._mapper = typeof(TRecord) == typeof(Dictionary<string, object?>)
@@ -94,7 +94,7 @@ public MongoDBVectorStoreRecordCollection(
         {
             VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
             VectorStoreName = mongoDatabase.DatabaseNamespace?.DatabaseName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -113,7 +113,7 @@ public async Task CreateCollectionAsync(CancellationToken cancellationToken = de
             {
                 VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = "CreateCollection"
             };
         }
@@ -127,13 +127,13 @@ public async Task CreateCollectionIfNotExistsAsync(CancellationToken cancellatio
         // The IMongoDatabase.CreateCollectionAsync "Creates a new collection if not already available".
         // So for CreateCollectionIfNotExistsAsync, we don't perform an additional check.
         await this.RunOperationAsync("CreateCollection",
-            () => this._mongoDatabase.CreateCollectionAsync(this.CollectionName, cancellationToken: cancellationToken)).ConfigureAwait(false);
+            () => this._mongoDatabase.CreateCollectionAsync(this.Name, cancellationToken: cancellationToken)).ConfigureAwait(false);
 
         await this.RunOperationWithRetryAsync(
             "CreateIndexes",
             this._options.MaxRetries,
             this._options.DelayInMilliseconds,
-            () => this.CreateIndexesAsync(this.CollectionName, cancellationToken),
+            () => this.CreateIndexesAsync(this.Name, cancellationToken),
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -159,7 +159,7 @@ await this.RunOperationAsync("DeleteMany", () => this._mongoCollection.DeleteMan
 
     /// <inheritdoc />
     public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
-        => this.RunOperationAsync("DropCollection", () => this._mongoDatabase.DropCollectionAsync(this.CollectionName, cancellationToken));
+        => this.RunOperationAsync("DropCollection", () => this._mongoDatabase.DropCollectionAsync(this.Name, cancellationToken));
 
     /// <inheritdoc />
     public async Task<TRecord?> GetAsync(TKey key, GetRecordOptions? options = null, CancellationToken cancellationToken = default)
@@ -187,7 +187,7 @@ public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
         return VectorStoreErrorHandler.RunModelConversion(
             MongoDBConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromStorageToDataModel(record, new() { IncludeVectors = includeVectors }));
     }
@@ -217,7 +217,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(
                     yield return VectorStoreErrorHandler.RunModelConversion(
                         MongoDBConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(record, new()));
                 }
@@ -236,7 +236,7 @@ public Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellationToke
         var storageModel = VectorStoreErrorHandler.RunModelConversion(
             MongoDBConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -374,7 +374,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
                 var record = VectorStoreErrorHandler.RunModelConversion(
                     MongoDBConstants.VectorStoreSystemName,
                     this._collectionMetadata.VectorStoreName,
-                    this.CollectionName,
+                    this.Name,
                     "GetAsync",
                     () => this._mapper.MapFromStorageToDataModel(response, new() { IncludeVectors = options.IncludeVectors }));
 
@@ -412,7 +412,7 @@ public async IAsyncEnumerable<VectorSearchResult<TRecord>> HybridSearchAsync<TVe
         BsonDocument[] pipeline = MongoDBVectorStoreCollectionSearchMapping.GetHybridSearchPipeline(
             vectorArray,
             keywords,
-            this.CollectionName,
+            this.Name,
             this._options.VectorIndexName,
             this._options.FullTextSearchIndexName,
             vectorProperty.StorageName,
@@ -569,7 +569,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> EnumerateAndMapSearc
                     var record = VectorStoreErrorHandler.RunModelConversion(
                         MongoDBConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(response[DocumentPropertyName].AsBsonDocument, new() { IncludeVectors = includeVectors }));
 
@@ -589,7 +589,7 @@ private FilterDefinition<BsonDocument> GetFilterByIds(IEnumerable<string> ids)
 
     private async Task<bool> InternalCollectionExistsAsync(CancellationToken cancellationToken)
     {
-        var filter = new BsonDocument("name", this.CollectionName);
+        var filter = new BsonDocument("name", this.Name);
         var options = new ListCollectionNamesOptions { Filter = filter };
 
         using var cursor = await this._mongoDatabase.ListCollectionNamesAsync(options, cancellationToken: cancellationToken).ConfigureAwait(false);
@@ -609,7 +609,7 @@ private async Task RunOperationAsync(string operationName, Func<Task> operation)
             {
                 VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -627,7 +627,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -659,7 +659,7 @@ private async Task RunOperationWithRetryAsync(
                     {
                         VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
                         VectorStoreName = this._collectionMetadata.VectorStoreName,
-                        CollectionName = this.CollectionName,
+                        CollectionName = this.Name,
                         OperationName = operationName
                     };
                 }
@@ -694,7 +694,7 @@ private async Task<T> RunOperationWithRetryAsync<T>(
                     {
                         VectorStoreSystemName = MongoDBConstants.VectorStoreSystemName,
                         VectorStoreName = this._collectionMetadata.VectorStoreName,
-                        CollectionName = this.CollectionName,
+                        CollectionName = this.Name,
                         OperationName = operationName
                     };
                 }
diff --git a/dotnet/src/Connectors/Connectors.Memory.Pinecone/PineconeVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Pinecone/PineconeVectorStoreRecordCollection.cs
index 220b1d0110e9..92b150310696 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Pinecone/PineconeVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Pinecone/PineconeVectorStoreRecordCollection.cs
@@ -38,7 +38,7 @@ public sealed class PineconeVectorStoreRecordCollection<TKey, TRecord> : IVector
     private IndexClient? _indexClient;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PineconeVectorStoreRecordCollection{TKey, TRecord}"/> class.
@@ -46,12 +46,12 @@ public sealed class PineconeVectorStoreRecordCollection<TKey, TRecord> : IVector
     /// <param name="pineconeClient">Pinecone client that can be used to manage the collections and vectors in a Pinecone store.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Thrown if the <paramref name="pineconeClient"/> is null.</exception>
-    /// <param name="collectionName">The name of the collection that this <see cref="PineconeVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="PineconeVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <exception cref="ArgumentException">Thrown for any misconfigured options.</exception>
-    public PineconeVectorStoreRecordCollection(Sdk.PineconeClient pineconeClient, string collectionName, PineconeVectorStoreRecordCollectionOptions<TRecord>? options = null)
+    public PineconeVectorStoreRecordCollection(Sdk.PineconeClient pineconeClient, string name, PineconeVectorStoreRecordCollectionOptions<TRecord>? options = null)
     {
         Verify.NotNull(pineconeClient);
-        VerifyCollectionName(collectionName);
+        VerifyCollectionName(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -59,7 +59,7 @@ public PineconeVectorStoreRecordCollection(Sdk.PineconeClient pineconeClient, st
         }
 
         this._pineconeClient = pineconeClient;
-        this.CollectionName = collectionName;
+        this.Name = name;
         this._options = options ?? new PineconeVectorStoreRecordCollectionOptions<TRecord>();
         this._model = new VectorStoreRecordModelBuilder(PineconeVectorStoreRecordFieldMapping.ModelBuildingOptions)
             .Build(typeof(TRecord), this._options.VectorStoreRecordDefinition);
@@ -68,7 +68,7 @@ public PineconeVectorStoreRecordCollection(Sdk.PineconeClient pineconeClient, st
         this._collectionMetadata = new()
         {
             VectorStoreSystemName = PineconeConstants.VectorStoreSystemName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -80,7 +80,7 @@ public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = de
             {
                 var collections = await this._pineconeClient.ListIndexesAsync(cancellationToken: cancellationToken).ConfigureAwait(false);
 
-                return collections.Indexes?.Any(x => x.Name == this.CollectionName) is true;
+                return collections.Indexes?.Any(x => x.Name == this.Name) is true;
             });
 
     /// <inheritdoc />
@@ -97,7 +97,7 @@ public Task CreateCollectionAsync(CancellationToken cancellationToken = default)
 
         CreateIndexRequest request = new()
         {
-            Name = this.CollectionName,
+            Name = this.Name,
             Dimension = vectorProperty.Dimensions,
             Metric = MapDistanceFunction(vectorProperty),
             Spec = new ServerlessIndexSpec
@@ -135,7 +135,7 @@ public async Task DeleteCollectionAsync(CancellationToken cancellationToken = de
     {
         try
         {
-            await this._pineconeClient.DeleteIndexAsync(this.CollectionName, cancellationToken: cancellationToken).ConfigureAwait(false);
+            await this._pineconeClient.DeleteIndexAsync(this.Name, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
         catch (NotFoundError)
         {
@@ -147,7 +147,7 @@ public async Task DeleteCollectionAsync(CancellationToken cancellationToken = de
             {
                 VectorStoreSystemName = PineconeConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = "DeleteCollection"
             };
         }
@@ -176,7 +176,7 @@ public async Task DeleteCollectionAsync(CancellationToken cancellationToken = de
         return VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "Get",
             () => this._mapper.MapFromStorageToDataModel(result, mapperOptions));
     }
@@ -221,7 +221,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(
         var records = VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "GetBatch",
             () => response.Vectors.Values.Select(x => this._mapper.MapFromStorageToDataModel(x, mapperOptions)));
 
@@ -281,7 +281,7 @@ public async Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellati
         var vector = VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "Upsert",
             () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -306,7 +306,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
         var vectors = VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "UpsertBatch",
             () => records.Select(this._mapper.MapFromDataToStorageModel).ToList());
 
@@ -379,7 +379,7 @@ public async IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync
         var records = VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "VectorizedSearch",
             () => skippedResults.Select(x => new VectorSearchResult<TRecord>(this._mapper.MapFromStorageToDataModel(new Sdk.Vector()
             {
@@ -434,7 +434,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
         var records = VectorStoreErrorHandler.RunModelConversion(
             PineconeConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             "Query",
             () => response.Matches.Skip(options.Skip).Select(x => this._mapper.MapFromStorageToDataModel(new Sdk.Vector()
             {
@@ -471,7 +471,7 @@ private async Task<T> RunIndexOperationAsync<T>(string operationName, Func<Index
             {
                 // If we don't provide "host" to the Index method, it's going to perform
                 // a blocking call to DescribeIndexAsync!!
-                string hostName = (await this._pineconeClient.DescribeIndexAsync(this.CollectionName).ConfigureAwait(false)).Host;
+                string hostName = (await this._pineconeClient.DescribeIndexAsync(this.Name).ConfigureAwait(false)).Host;
                 this._indexClient = this._pineconeClient.Index(host: hostName);
             }
 
@@ -483,7 +483,7 @@ private async Task<T> RunIndexOperationAsync<T>(string operationName, Func<Index
             {
                 VectorStoreSystemName = PineconeConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -501,7 +501,7 @@ private async Task<T> RunCollectionOperationAsync<T>(string operationName, Func<
             {
                 VectorStoreSystemName = PineconeConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
diff --git a/dotnet/src/Connectors/Connectors.Memory.Postgres/PostgresVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Postgres/PostgresVectorStoreRecordCollection.cs
index aab25cfe6d1f..3932bebb2ac8 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Postgres/PostgresVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Postgres/PostgresVectorStoreRecordCollection.cs
@@ -24,7 +24,7 @@ public sealed class PostgresVectorStoreRecordCollection<TKey, TRecord> : IVector
     where TRecord : notnull
 {
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>Metadata about vector store record collection.</summary>
     private readonly VectorStoreRecordCollectionMetadata _collectionMetadata;
@@ -48,10 +48,10 @@ public sealed class PostgresVectorStoreRecordCollection<TKey, TRecord> : IVector
     /// Initializes a new instance of the <see cref="PostgresVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="dataSource">The data source to use for connecting to the database.</param>
-    /// <param name="collectionName">The name of the collection.</param>
+    /// <param name="name">The name of the collection.</param>
     /// <param name="options">Optional configuration options for this class.</param>
-    public PostgresVectorStoreRecordCollection(NpgsqlDataSource dataSource, string collectionName, PostgresVectorStoreRecordCollectionOptions<TRecord>? options = default)
-        : this(new PostgresVectorStoreDbClient(dataSource), collectionName, options)
+    public PostgresVectorStoreRecordCollection(NpgsqlDataSource dataSource, string name, PostgresVectorStoreRecordCollectionOptions<TRecord>? options = default)
+        : this(new PostgresVectorStoreDbClient(dataSource), name, options)
     {
     }
 
@@ -59,20 +59,20 @@ public PostgresVectorStoreRecordCollection(NpgsqlDataSource dataSource, string c
     /// Initializes a new instance of the <see cref="PostgresVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="client">The client to use for interacting with the database.</param>
-    /// <param name="collectionName">The name of the collection.</param>
+    /// <param name="name">The name of the collection.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <remarks>
     /// This constructor is internal. It allows internal code to create an instance of this class with a custom client.
     /// </remarks>
-    internal PostgresVectorStoreRecordCollection(IPostgresVectorStoreDbClient client, string collectionName, PostgresVectorStoreRecordCollectionOptions<TRecord>? options = default)
+    internal PostgresVectorStoreRecordCollection(IPostgresVectorStoreDbClient client, string name, PostgresVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(client);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         // Assign.
         this._client = client;
-        this.CollectionName = collectionName;
+        this.Name = name;
         this._options = options ?? new PostgresVectorStoreRecordCollectionOptions<TRecord>();
 
         this._model = new VectorStoreRecordModelBuilder(PostgresConstants.ModelBuildingOptions)
@@ -84,7 +84,7 @@ internal PostgresVectorStoreRecordCollection(IPostgresVectorStoreDbClient client
         {
             VectorStoreSystemName = PostgresConstants.VectorStoreSystemName,
             VectorStoreName = this._client.DatabaseName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -93,7 +93,7 @@ public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = de
     {
         const string OperationName = "DoesTableExists";
         return this.RunOperationAsync(OperationName, () =>
-            this._client.DoesTableExistsAsync(this.CollectionName, cancellationToken)
+            this._client.DoesTableExistsAsync(this.Name, cancellationToken)
         );
     }
 
@@ -120,7 +120,7 @@ public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
     {
         const string OperationName = "DeleteCollection";
         return this.RunOperationAsync(OperationName, () =>
-            this._client.DeleteTableAsync(this.CollectionName, cancellationToken)
+            this._client.DeleteTableAsync(this.Name, cancellationToken)
         );
     }
 
@@ -132,7 +132,7 @@ public Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellationToke
         var storageModel = VectorStoreErrorHandler.RunModelConversion(
             PostgresConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -144,7 +144,7 @@ public Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellationToke
 
         return this.RunOperationAsync(OperationName, async () =>
             {
-                await this._client.UpsertAsync(this.CollectionName, storageModel, this._model.KeyProperty.StorageName, cancellationToken).ConfigureAwait(false);
+                await this._client.UpsertAsync(this.Name, storageModel, this._model.KeyProperty.StorageName, cancellationToken).ConfigureAwait(false);
                 return key;
             }
         );
@@ -160,7 +160,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
         var storageModels = records.Select(record => VectorStoreErrorHandler.RunModelConversion(
             PostgresConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record))).ToList();
 
@@ -172,7 +172,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
         var keys = storageModels.Select(model => model[this._model.KeyProperty.StorageName]!).ToList();
 
         await this.RunOperationAsync(OperationName, () =>
-            this._client.UpsertBatchAsync(this.CollectionName, storageModels, this._model.KeyProperty.StorageName, cancellationToken)
+            this._client.UpsertBatchAsync(this.Name, storageModels, this._model.KeyProperty.StorageName, cancellationToken)
         ).ConfigureAwait(false);
 
         return keys.Select(key => (TKey)key!).ToList();
@@ -189,13 +189,13 @@ await this.RunOperationAsync(OperationName, () =>
 
         return this.RunOperationAsync<TRecord?>(OperationName, async () =>
         {
-            var row = await this._client.GetAsync(this.CollectionName, key, this._model, includeVectors, cancellationToken).ConfigureAwait(false);
+            var row = await this._client.GetAsync(this.Name, key, this._model, includeVectors, cancellationToken).ConfigureAwait(false);
 
             if (row is null) { return default; }
             return VectorStoreErrorHandler.RunModelConversion(
                 PostgresConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 OperationName,
                 () => this._mapper.MapFromStorageToDataModel(row, new() { IncludeVectors = includeVectors }));
         });
@@ -211,19 +211,19 @@ public IAsyncEnumerable<TRecord> GetAsync(IEnumerable<TKey> keys, GetRecordOptio
         bool includeVectors = options?.IncludeVectors is true;
 
         return PostgresVectorStoreUtils.WrapAsyncEnumerableAsync(
-            this._client.GetBatchAsync(this.CollectionName, keys, this._model, includeVectors, cancellationToken)
+            this._client.GetBatchAsync(this.Name, keys, this._model, includeVectors, cancellationToken)
                 .SelectAsync(row =>
                     VectorStoreErrorHandler.RunModelConversion(
                         PostgresConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(row, new() { IncludeVectors = includeVectors })),
                     cancellationToken
                 ),
             OperationName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName
+            this.Name
         );
     }
 
@@ -232,7 +232,7 @@ public Task DeleteAsync(TKey key, CancellationToken cancellationToken = default)
     {
         const string OperationName = "Delete";
         return this.RunOperationAsync(OperationName, () =>
-            this._client.DeleteAsync(this.CollectionName, this._model.KeyProperty.StorageName, key, cancellationToken)
+            this._client.DeleteAsync(this.Name, this._model.KeyProperty.StorageName, key, cancellationToken)
         );
     }
 
@@ -243,7 +243,7 @@ public Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancellationTo
 
         const string OperationName = "DeleteBatch";
         return this.RunOperationAsync(OperationName, () =>
-            this._client.DeleteBatchAsync(this.CollectionName, this._model.KeyProperty.StorageName, keys, cancellationToken)
+            this._client.DeleteBatchAsync(this.Name, this._model.KeyProperty.StorageName, keys, cancellationToken)
         );
     }
 
@@ -278,13 +278,13 @@ public IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync<TVect
         StorageToDataModelMapperOptions mapperOptions = new() { IncludeVectors = searchOptions.IncludeVectors };
 
         return PostgresVectorStoreUtils.WrapAsyncEnumerableAsync(
-            this._client.GetNearestMatchesAsync(this.CollectionName, this._model, vectorProperty, pgVector, top, searchOptions, cancellationToken)
+            this._client.GetNearestMatchesAsync(this.Name, this._model, vectorProperty, pgVector, top, searchOptions, cancellationToken)
                 .SelectAsync(result =>
                 {
                     var record = VectorStoreErrorHandler.RunModelConversion(
                         PostgresConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         OperationName,
                         () => this._mapper.MapFromStorageToDataModel(result.Row, mapperOptions));
 
@@ -292,7 +292,7 @@ public IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync<TVect
                 }, cancellationToken),
             OperationName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName
+            this.Name
         );
     }
 
@@ -308,19 +308,19 @@ public IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>> filter
         StorageToDataModelMapperOptions mapperOptions = new() { IncludeVectors = options.IncludeVectors };
 
         return PostgresVectorStoreUtils.WrapAsyncEnumerableAsync(
-            this._client.GetMatchingRecordsAsync(this.CollectionName, this._model, filter, top, options, cancellationToken)
+            this._client.GetMatchingRecordsAsync(this.Name, this._model, filter, top, options, cancellationToken)
                 .SelectAsync(dictionary =>
                 {
                     return VectorStoreErrorHandler.RunModelConversion(
                         PostgresConstants.VectorStoreSystemName,
                         this._collectionMetadata.VectorStoreName,
-                        this.CollectionName,
+                        this.Name,
                         "Get",
                         () => this._mapper.MapFromStorageToDataModel(dictionary, mapperOptions));
                 }, cancellationToken),
             "Get",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName);
+            this.Name);
     }
 
     /// <inheritdoc />
@@ -338,7 +338,7 @@ public IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>> filter
 
     private Task InternalCreateCollectionAsync(bool ifNotExists, CancellationToken cancellationToken = default)
     {
-        return this._client.CreateTableAsync(this.CollectionName, this._model, ifNotExists, cancellationToken);
+        return this._client.CreateTableAsync(this.Name, this._model, ifNotExists, cancellationToken);
     }
 
     private async Task RunOperationAsync(string operationName, Func<Task> operation)
@@ -353,7 +353,7 @@ private async Task RunOperationAsync(string operationName, Func<Task> operation)
             {
                 VectorStoreSystemName = PostgresConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -371,7 +371,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = PostgresConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
diff --git a/dotnet/src/Connectors/Connectors.Memory.Qdrant/QdrantVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Qdrant/QdrantVectorStoreRecordCollection.cs
index 91aeb02b170d..101a907805f1 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Qdrant/QdrantVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Qdrant/QdrantVectorStoreRecordCollection.cs
@@ -62,12 +62,12 @@ public sealed class QdrantVectorStoreRecordCollection<TKey, TRecord> : IVectorSt
     /// Initializes a new instance of the <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="qdrantClient">Qdrant client that can be used to manage the collections and points in a Qdrant store.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Thrown if the <paramref name="qdrantClient"/> is null.</exception>
     /// <exception cref="ArgumentException">Thrown for any misconfigured options.</exception>
-    public QdrantVectorStoreRecordCollection(QdrantClient qdrantClient, string collectionName, QdrantVectorStoreRecordCollectionOptions<TRecord>? options = null)
-        : this(new MockableQdrantClient(qdrantClient), collectionName, options)
+    public QdrantVectorStoreRecordCollection(QdrantClient qdrantClient, string name, QdrantVectorStoreRecordCollectionOptions<TRecord>? options = null)
+        : this(new MockableQdrantClient(qdrantClient), name, options)
     {
     }
 
@@ -75,15 +75,15 @@ public QdrantVectorStoreRecordCollection(QdrantClient qdrantClient, string colle
     /// Initializes a new instance of the <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="qdrantClient">Qdrant client that can be used to manage the collections and points in a Qdrant store.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="QdrantVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Thrown if the <paramref name="qdrantClient"/> is null.</exception>
     /// <exception cref="ArgumentException">Thrown for any misconfigured options.</exception>
-    internal QdrantVectorStoreRecordCollection(MockableQdrantClient qdrantClient, string collectionName, QdrantVectorStoreRecordCollectionOptions<TRecord>? options = null)
+    internal QdrantVectorStoreRecordCollection(MockableQdrantClient qdrantClient, string name, QdrantVectorStoreRecordCollectionOptions<TRecord>? options = null)
     {
         // Verify.
         Verify.NotNull(qdrantClient);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(ulong) && typeof(TKey) != typeof(Guid) && typeof(TKey) != typeof(object))
         {
@@ -92,7 +92,7 @@ internal QdrantVectorStoreRecordCollection(MockableQdrantClient qdrantClient, st
 
         // Assign.
         this._qdrantClient = qdrantClient;
-        this._collectionName = collectionName;
+        this._collectionName = name;
         this._options = options ?? new QdrantVectorStoreRecordCollectionOptions<TRecord>();
 
         this._model = new VectorStoreRecordModelBuilder(QdrantVectorStoreRecordFieldMapping.GetModelBuildOptions(this._options.HasNamedVectors))
@@ -103,12 +103,12 @@ internal QdrantVectorStoreRecordCollection(MockableQdrantClient qdrantClient, st
         this._collectionMetadata = new()
         {
             VectorStoreSystemName = QdrantConstants.VectorStoreSystemName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._collectionName;
+    public string Name => this._collectionName;
 
     /// <inheritdoc />
     public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
@@ -511,7 +511,7 @@ public async IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync
         var points = await this.RunOperationAsync(
             "Query",
             () => this._qdrantClient.QueryAsync(
-                this.CollectionName,
+                this.Name,
                 query: query,
                 usingVector: this._options.HasNamedVectors ? vectorProperty.StorageName : null,
                 filter: filter,
@@ -570,7 +570,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
         var scrollResponse = await this.RunOperationAsync(
             "Scroll",
             () => this._qdrantClient.ScrollAsync(
-                this.CollectionName,
+                this.Name,
                 translatedFilter,
                 vectorsSelector,
                 limit: (uint)(top + options.Skip),
@@ -657,7 +657,7 @@ public async IAsyncEnumerable<VectorSearchResult<TRecord>> HybridSearchAsync<TVe
         var points = await this.RunOperationAsync(
             "Query",
             () => this._qdrantClient.QueryAsync(
-                this.CollectionName,
+                this.Name,
                 prefetch: new List<PrefetchQuery>() { vectorQuery, keywordQuery },
                 query: fusionQuery,
                 limit: (ulong)top,
diff --git a/dotnet/src/Connectors/Connectors.Memory.Redis/RedisHashSetVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Redis/RedisHashSetVectorStoreRecordCollection.cs
index 219a865cc12c..53000a1dcbb1 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Redis/RedisHashSetVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Redis/RedisHashSetVectorStoreRecordCollection.cs
@@ -93,14 +93,14 @@ public sealed class RedisHashSetVectorStoreRecordCollection<TKey, TRecord> : IVe
     /// Initializes a new instance of the <see cref="RedisHashSetVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="database">The Redis database to read/write records from.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="RedisHashSetVectorStoreRecordCollectionOptions{TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="RedisHashSetVectorStoreRecordCollectionOptions{TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Throw when parameters are invalid.</exception>
-    public RedisHashSetVectorStoreRecordCollection(IDatabase database, string collectionName, RedisHashSetVectorStoreRecordCollectionOptions<TRecord>? options = null)
+    public RedisHashSetVectorStoreRecordCollection(IDatabase database, string name, RedisHashSetVectorStoreRecordCollectionOptions<TRecord>? options = null)
     {
         // Verify.
         Verify.NotNull(database);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -109,7 +109,7 @@ public RedisHashSetVectorStoreRecordCollection(IDatabase database, string collec
 
         // Assign.
         this._database = database;
-        this._collectionName = collectionName;
+        this._collectionName = name;
         this._options = options ?? new RedisHashSetVectorStoreRecordCollectionOptions<TRecord>();
         this._model = new VectorStoreRecordModelBuilder(ModelBuildingOptions).Build(typeof(TRecord), this._options.VectorStoreRecordDefinition);
 
@@ -124,12 +124,12 @@ public RedisHashSetVectorStoreRecordCollection(IDatabase database, string collec
         {
             VectorStoreSystemName = RedisConstants.VectorStoreSystemName,
             VectorStoreName = database.Database.ToString(),
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._collectionName;
+    public string Name => this._collectionName;
 
     /// <inheritdoc />
     public async Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
diff --git a/dotnet/src/Connectors/Connectors.Memory.Redis/RedisJsonVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Redis/RedisJsonVectorStoreRecordCollection.cs
index 097095953866..0c79dd5d65e9 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Redis/RedisJsonVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Redis/RedisJsonVectorStoreRecordCollection.cs
@@ -84,14 +84,14 @@ public sealed class RedisJsonVectorStoreRecordCollection<TKey, TRecord> : IVecto
     /// Initializes a new instance of the <see cref="RedisJsonVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="database">The Redis database to read/write records from.</param>
-    /// <param name="collectionName">The name of the collection that this <see cref="RedisJsonVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="RedisJsonVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <exception cref="ArgumentNullException">Throw when parameters are invalid.</exception>
-    public RedisJsonVectorStoreRecordCollection(IDatabase database, string collectionName, RedisJsonVectorStoreRecordCollectionOptions<TRecord>? options = null)
+    public RedisJsonVectorStoreRecordCollection(IDatabase database, string name, RedisJsonVectorStoreRecordCollectionOptions<TRecord>? options = null)
     {
         // Verify.
         Verify.NotNull(database);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(object))
         {
@@ -100,7 +100,7 @@ public RedisJsonVectorStoreRecordCollection(IDatabase database, string collectio
 
         // Assign.
         this._database = database;
-        this._collectionName = collectionName;
+        this._collectionName = name;
         this._options = options ?? new RedisJsonVectorStoreRecordCollectionOptions<TRecord>();
         this._jsonSerializerOptions = this._options.JsonSerializerOptions ?? JsonSerializerOptions.Default;
         this._model = new VectorStoreRecordJsonModelBuilder(ModelBuildingOptions)
@@ -118,12 +118,12 @@ public RedisJsonVectorStoreRecordCollection(IDatabase database, string collectio
         {
             VectorStoreSystemName = RedisConstants.VectorStoreSystemName,
             VectorStoreName = database.Database.ToString(),
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
     /// <inheritdoc />
-    public string CollectionName => this._collectionName;
+    public string Name => this._collectionName;
 
     /// <inheritdoc />
     public async Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
diff --git a/dotnet/src/Connectors/Connectors.Memory.SqlServer/SqlServerVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.SqlServer/SqlServerVectorStoreRecordCollection.cs
index 9036cddd2575..6d20ef10d89c 100644
--- a/dotnet/src/Connectors/Connectors.Memory.SqlServer/SqlServerVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.SqlServer/SqlServerVectorStoreRecordCollection.cs
@@ -52,7 +52,7 @@ public SqlServerVectorStoreRecordCollection(
             .Build(typeof(TRecord), options?.RecordDefinition);
 
         this._connectionString = connectionString;
-        this.CollectionName = name;
+        this.Name = name;
         // We need to create a copy, so any changes made to the option bag after
         // the ctor call do not affect this instance.
         this._options = options is null
@@ -75,14 +75,14 @@ public SqlServerVectorStoreRecordCollection(
     }
 
     /// <inheritdoc/>
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <inheritdoc/>
     public async Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = default)
     {
         using SqlConnection connection = new(this._connectionString);
         using SqlCommand command = SqlServerCommandBuilder.SelectTableName(
-            connection, this._options.Schema, this.CollectionName);
+            connection, this._options.Schema, this.Name);
 
         return await ExceptionWrapper.WrapAsync(connection, command,
             static async (cmd, ct) =>
@@ -92,7 +92,7 @@ static async (cmd, ct) =>
             },
             "CollectionExists",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -110,7 +110,7 @@ private async Task CreateCollectionAsync(bool ifNotExists, CancellationToken can
         using SqlCommand command = SqlServerCommandBuilder.CreateTable(
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             ifNotExists,
             this._model);
 
@@ -118,7 +118,7 @@ await ExceptionWrapper.WrapAsync(connection, command,
             static (cmd, ct) => cmd.ExecuteNonQueryAsync(ct),
             "CreateCollection",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -127,13 +127,13 @@ public async Task DeleteCollectionAsync(CancellationToken cancellationToken = de
     {
         using SqlConnection connection = new(this._connectionString);
         using SqlCommand command = SqlServerCommandBuilder.DropTableIfExists(
-            connection, this._options.Schema, this.CollectionName);
+            connection, this._options.Schema, this.Name);
 
         await ExceptionWrapper.WrapAsync(connection, command,
             static (cmd, ct) => cmd.ExecuteNonQueryAsync(ct),
             "DeleteCollection",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -146,7 +146,7 @@ public async Task DeleteAsync(TKey key, CancellationToken cancellationToken = de
         using SqlCommand command = SqlServerCommandBuilder.DeleteSingle(
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             this._model.KeyProperty,
             key);
 
@@ -154,7 +154,7 @@ await ExceptionWrapper.WrapAsync(connection, command,
             static (cmd, ct) => cmd.ExecuteNonQueryAsync(ct),
             "Delete",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -183,7 +183,7 @@ public async Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancella
                     if (!SqlServerCommandBuilder.DeleteMany(
                         command,
                         this._options.Schema,
-                        this.CollectionName,
+                        this.Name,
                         this._model.KeyProperty,
                         keys.Skip(taken).Take(SqlServerConstants.MaxParameterCount)))
                     {
@@ -220,7 +220,7 @@ public async Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancella
             {
                 VectorStoreSystemName = SqlServerConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = "DeleteBatch"
             };
         }
@@ -237,7 +237,7 @@ public async Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancella
         using SqlCommand command = SqlServerCommandBuilder.SelectSingle(
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             this._model,
             key,
             includeVectors);
@@ -251,7 +251,7 @@ static async (cmd, ct) =>
             },
             "Get",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
 
         return reader.HasRows
@@ -283,7 +283,7 @@ public async IAsyncEnumerable<TRecord> GetAsync(IEnumerable<TKey> keys, GetRecor
             if (!SqlServerCommandBuilder.SelectMany(
                 command,
                 this._options.Schema,
-                this.CollectionName,
+                this.Name,
                 this._model,
                 keys.Skip(taken).Take(SqlServerConstants.MaxParameterCount),
                 includeVectors))
@@ -300,14 +300,14 @@ public async IAsyncEnumerable<TRecord> GetAsync(IEnumerable<TKey> keys, GetRecor
                 static (cmd, ct) => cmd.ExecuteReaderAsync(ct),
                 "GetBatch",
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 cancellationToken).ConfigureAwait(false);
 
             while (await ExceptionWrapper.WrapReadAsync(
                 reader,
                 "GetBatch",
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 cancellationToken).ConfigureAwait(false))
             {
                 yield return this._mapper.MapFromStorageToDataModel(
@@ -326,7 +326,7 @@ public async Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellati
         using SqlCommand command = SqlServerCommandBuilder.MergeIntoSingle(
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             this._model,
             this._mapper.MapFromDataToStorageModel(record));
 
@@ -339,7 +339,7 @@ async static (cmd, ct) =>
             },
             "Upsert",
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             cancellationToken).ConfigureAwait(false);
     }
 
@@ -369,7 +369,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
                     if (!SqlServerCommandBuilder.MergeIntoMany(
                         command,
                         this._options.Schema,
-                        this.CollectionName,
+                        this.Name,
                         this._model,
                         records.Skip(taken)
                                .Take(SqlServerConstants.MaxParameterCount / parametersPerRecord)
@@ -408,7 +408,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
             {
                 VectorStoreSystemName = SqlServerConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = "UpsertBatch"
             };
         }
@@ -447,7 +447,7 @@ public IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync<TVect
         SqlCommand command = SqlServerCommandBuilder.SelectVector(
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             vectorProperty,
             this._model,
             top,
@@ -485,7 +485,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> ReadVectorSearchResu
                 static (cmd, ct) => cmd.ExecuteReaderAsync(ct),
                 "VectorizedSearch",
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 cancellationToken).ConfigureAwait(false);
 
             int scoreIndex = -1;
@@ -493,7 +493,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> ReadVectorSearchResu
                 reader,
                 "VectorizedSearch",
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 cancellationToken).ConfigureAwait(false))
             {
                 if (scoreIndex < 0)
@@ -529,12 +529,12 @@ public async IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>>
             options,
             connection,
             this._options.Schema,
-            this.CollectionName,
+            this.Name,
             this._model);
 
         using SqlDataReader reader = await ExceptionWrapper.WrapAsync(connection, command,
             static (cmd, ct) => cmd.ExecuteReaderAsync(ct),
-            "GetAsync", this._collectionMetadata.VectorStoreName, this.CollectionName, cancellationToken).ConfigureAwait(false);
+            "GetAsync", this._collectionMetadata.VectorStoreName, this.Name, cancellationToken).ConfigureAwait(false);
 
         var vectorProperties = options.IncludeVectors ? this._model.VectorProperties : [];
         StorageToDataModelMapperOptions mapperOptions = new() { IncludeVectors = options.IncludeVectors };
diff --git a/dotnet/src/Connectors/Connectors.Memory.Sqlite/SqliteVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Sqlite/SqliteVectorStoreRecordCollection.cs
index 4006d5c21006..1d1a044f6eb5 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Sqlite/SqliteVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Sqlite/SqliteVectorStoreRecordCollection.cs
@@ -72,22 +72,22 @@ public sealed class SqliteVectorStoreRecordCollection<TKey, TRecord> : IVectorSt
     private readonly string _vectorSearchExtensionName;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="SqliteVectorStoreRecordCollection{TKey, TRecord}"/> class.
     /// </summary>
     /// <param name="connectionString">The connection string for the SQLite database represented by this <see cref="SqliteVectorStore"/>.</param>
-    /// <param name="collectionName">The name of the collection/table that this <see cref="SqliteVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection/table that this <see cref="SqliteVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     public SqliteVectorStoreRecordCollection(
         string connectionString,
-        string collectionName,
+        string name,
         SqliteVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(connectionString);
-        Verify.NotNullOrWhiteSpace(collectionName);
+        Verify.NotNullOrWhiteSpace(name);
 
         if (typeof(TKey) != typeof(string) && typeof(TKey) != typeof(ulong) && typeof(TKey) != typeof(object))
         {
@@ -96,11 +96,11 @@ public SqliteVectorStoreRecordCollection(
 
         // Assign.
         this._connectionString = connectionString;
-        this.CollectionName = collectionName;
+        this.Name = name;
         this._options = options ?? new();
         this._vectorSearchExtensionName = this._options.VectorSearchExtensionName ?? SqliteConstants.VectorSearchExtensionName;
 
-        this._dataTableName = this.CollectionName;
+        this._dataTableName = this.Name;
         this._vectorTableName = GetVectorTableName(this._dataTableName, this._options);
 
         this._model = new VectorStoreRecordModelBuilder(SqliteConstants.ModelBuildingOptions)
@@ -144,7 +144,7 @@ public SqliteVectorStoreRecordCollection(
         {
             VectorStoreSystemName = SqliteConstants.VectorStoreSystemName,
             VectorStoreName = connectionStringBuilder.DataSource,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -347,7 +347,7 @@ public async Task<TKey> UpsertAsync(TRecord record, CancellationToken cancellati
         var storageModel = VectorStoreErrorHandler.RunModelConversion(
             SqliteConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record));
 
@@ -373,7 +373,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
         var storageModels = records.Select(record => VectorStoreErrorHandler.RunModelConversion(
             SqliteConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record))).ToList();
 
@@ -687,7 +687,7 @@ private TRecord GetAndMapRecord(
         return VectorStoreErrorHandler.RunModelConversion(
             SqliteConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             operationName,
             () => this._mapper.MapFromStorageToDataModel(storageModel, new() { IncludeVectors = includeVectors }));
     }
@@ -704,7 +704,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = SqliteConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
diff --git a/dotnet/src/Connectors/Connectors.Memory.Weaviate/WeaviateVectorStoreRecordCollection.cs b/dotnet/src/Connectors/Connectors.Memory.Weaviate/WeaviateVectorStoreRecordCollection.cs
index 49a07cad043e..7275b1b5e08b 100644
--- a/dotnet/src/Connectors/Connectors.Memory.Weaviate/WeaviateVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/Connectors.Memory.Weaviate/WeaviateVectorStoreRecordCollection.cs
@@ -68,7 +68,7 @@ public sealed class WeaviateVectorStoreRecordCollection<TKey, TRecord> : IVector
     private readonly string? _apiKey;
 
     /// <inheritdoc />
-    public string CollectionName { get; }
+    public string Name { get; }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="WeaviateVectorStoreRecordCollection{TKey, TRecord}"/> class.
@@ -78,17 +78,17 @@ public sealed class WeaviateVectorStoreRecordCollection<TKey, TRecord> : IVector
     /// <see cref="HttpClient.BaseAddress"/> should point to remote or local cluster and API key can be configured via <see cref="HttpClient.DefaultRequestHeaders"/>.
     /// It's also possible to provide these parameters via <see cref="WeaviateVectorStoreRecordCollectionOptions{TRecord}"/>.
     /// </param>
-    /// <param name="collectionName">The name of the collection that this <see cref="WeaviateVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
+    /// <param name="name">The name of the collection that this <see cref="WeaviateVectorStoreRecordCollection{TKey, TRecord}"/> will access.</param>
     /// <param name="options">Optional configuration options for this class.</param>
     /// <remarks>The collection name must start with a capital letter and contain only ASCII letters and digits.</remarks>
     public WeaviateVectorStoreRecordCollection(
         HttpClient httpClient,
-        string collectionName,
+        string name,
         WeaviateVectorStoreRecordCollectionOptions<TRecord>? options = default)
     {
         // Verify.
         Verify.NotNull(httpClient);
-        VerifyCollectionName(collectionName);
+        VerifyCollectionName(name);
 
         if (typeof(TKey) != typeof(Guid) && typeof(TKey) != typeof(object))
         {
@@ -100,20 +100,20 @@ public WeaviateVectorStoreRecordCollection(
         // Assign.
         this._httpClient = httpClient;
         this._endpoint = endpoint;
-        this.CollectionName = collectionName;
+        this.Name = name;
         this._options = options ?? new();
         this._apiKey = this._options.ApiKey;
         this._model = new WeaviateModelBuilder().Build(typeof(TRecord), this._options.VectorStoreRecordDefinition, s_jsonSerializerOptions);
 
         // Assign mapper.
         this._mapper = typeof(TRecord) == typeof(Dictionary<string, object?>)
-            ? (new WeaviateDynamicDataModelMapper(this.CollectionName, this._model, s_jsonSerializerOptions) as IWeaviateMapper<TRecord>)!
-            : new WeaviateVectorStoreRecordMapper<TRecord>(this.CollectionName, this._model, s_jsonSerializerOptions);
+            ? (new WeaviateDynamicDataModelMapper(this.Name, this._model, s_jsonSerializerOptions) as IWeaviateMapper<TRecord>)!
+            : new WeaviateVectorStoreRecordMapper<TRecord>(this.Name, this._model, s_jsonSerializerOptions);
 
         this._collectionMetadata = new()
         {
             VectorStoreSystemName = WeaviateConstants.VectorStoreSystemName,
-            CollectionName = collectionName
+            CollectionName = name
         };
     }
 
@@ -124,7 +124,7 @@ public Task<bool> CollectionExistsAsync(CancellationToken cancellationToken = de
 
         return this.RunOperationAsync(OperationName, async () =>
         {
-            var request = new WeaviateGetCollectionSchemaRequest(this.CollectionName).Build();
+            var request = new WeaviateGetCollectionSchemaRequest(this.Name).Build();
 
             var response = await this
                 .ExecuteRequestWithNotFoundHandlingAsync<WeaviateGetCollectionSchemaResponse>(request, cancellationToken)
@@ -141,7 +141,7 @@ public Task CreateCollectionAsync(CancellationToken cancellationToken = default)
 
         return this.RunOperationAsync(OperationName, () =>
         {
-            var schema = WeaviateVectorStoreCollectionCreateMapping.MapToSchema(this.CollectionName, this._model);
+            var schema = WeaviateVectorStoreCollectionCreateMapping.MapToSchema(this.Name, this._model);
 
             var request = new WeaviateCreateCollectionSchemaRequest(schema).Build();
 
@@ -165,7 +165,7 @@ public Task DeleteCollectionAsync(CancellationToken cancellationToken = default)
 
         return this.RunOperationAsync(OperationName, () =>
         {
-            var request = new WeaviateDeleteCollectionSchemaRequest(this.CollectionName).Build();
+            var request = new WeaviateDeleteCollectionSchemaRequest(this.Name).Build();
 
             return this.ExecuteRequestAsync(request, cancellationToken);
         });
@@ -185,7 +185,7 @@ public Task DeleteAsync(TKey key, CancellationToken cancellationToken = default)
                 _ => throw new UnreachableException("Guid key should have been validated during model building")
             };
 
-            var request = new WeaviateDeleteObjectRequest(this.CollectionName, guid).Build();
+            var request = new WeaviateDeleteObjectRequest(this.Name, guid).Build();
 
             return this.ExecuteRequestAsync(request, cancellationToken);
         });
@@ -210,7 +210,7 @@ public Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancellationTo
         {
             var match = new WeaviateQueryMatch
             {
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 WhereClause = new WeaviateQueryMatchWhereClause
                 {
                     Operator = ContainsAnyOperator,
@@ -240,7 +240,7 @@ public Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancellationTo
             };
 
             var includeVectors = options?.IncludeVectors is true;
-            var request = new WeaviateGetCollectionObjectRequest(this.CollectionName, guid, includeVectors).Build();
+            var request = new WeaviateGetCollectionObjectRequest(this.Name, guid, includeVectors).Build();
 
             var jsonObject = await this.ExecuteRequestWithNotFoundHandlingAsync<JsonObject>(request, cancellationToken).ConfigureAwait(false);
 
@@ -252,7 +252,7 @@ public Task DeleteAsync(IEnumerable<TKey> keys, CancellationToken cancellationTo
             return VectorStoreErrorHandler.RunModelConversion(
                 WeaviateConstants.VectorStoreSystemName,
                 this._collectionMetadata.VectorStoreName,
-                this.CollectionName,
+                this.Name,
                 OperationName,
                 () => this._mapper.MapFromStorageToDataModel(jsonObject!, new() { IncludeVectors = includeVectors }));
         });
@@ -297,7 +297,7 @@ public async Task<IReadOnlyList<TKey>> UpsertAsync(IEnumerable<TRecord> records,
         var jsonObjects = records.Select(record => VectorStoreErrorHandler.RunModelConversion(
             WeaviateConstants.VectorStoreSystemName,
             this._collectionMetadata.VectorStoreName,
-            this.CollectionName,
+            this.Name,
             OperationName,
             () => this._mapper.MapFromDataToStorageModel(record))).ToList();
 
@@ -346,7 +346,7 @@ public IAsyncEnumerable<VectorSearchResult<TRecord>> VectorizedSearchAsync<TVect
 
         var query = WeaviateVectorStoreRecordCollectionQueryBuilder.BuildSearchQuery(
             vector,
-            this.CollectionName,
+            this.Name,
             vectorProperty.StorageName,
             s_jsonSerializerOptions,
             top,
@@ -369,7 +369,7 @@ public IAsyncEnumerable<TRecord> GetAsync(Expression<Func<TRecord, bool>> filter
             filter,
             top,
             options,
-            this.CollectionName,
+            this.Name,
             this._model);
 
         return this.ExecuteQueryAsync(query, options.IncludeVectors, WeaviateConstants.ScorePropertyName, "GetAsync", cancellationToken)
@@ -392,7 +392,7 @@ public IAsyncEnumerable<VectorSearchResult<TRecord>> HybridSearchAsync<TVector>(
             vector,
             top,
             string.Join(" ", keywords),
-            this.CollectionName,
+            this.Name,
             this._model,
             vectorProperty,
             textDataProperty,
@@ -423,7 +423,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> ExecuteQueryAsync(st
 
         var (responseModel, content) = await this.ExecuteRequestWithResponseContentAsync<WeaviateVectorSearchResponse>(request, cancellationToken).ConfigureAwait(false);
 
-        var collectionResults = responseModel?.Data?.GetOperation?[this.CollectionName];
+        var collectionResults = responseModel?.Data?.GetOperation?[this.Name];
 
         if (collectionResults is null)
         {
@@ -431,7 +431,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> ExecuteQueryAsync(st
             {
                 VectorStoreSystemName = WeaviateConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
@@ -445,7 +445,7 @@ private async IAsyncEnumerable<VectorSearchResult<TRecord>> ExecuteQueryAsync(st
                 var record = VectorStoreErrorHandler.RunModelConversion(
                     WeaviateConstants.VectorStoreSystemName,
                     this._collectionMetadata.VectorStoreName,
-                    this.CollectionName,
+                    this.Name,
                     operationName,
                     () => this._mapper.MapFromStorageToDataModel(storageModel, new() { IncludeVectors = includeVectors }));
 
@@ -510,7 +510,7 @@ private async Task<T> RunOperationAsync<T>(string operationName, Func<Task<T>> o
             {
                 VectorStoreSystemName = WeaviateConstants.VectorStoreSystemName,
                 VectorStoreName = this._collectionMetadata.VectorStoreName,
-                CollectionName = this.CollectionName,
+                CollectionName = this.Name,
                 OperationName = operationName
             };
         }
diff --git a/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/IVectorStoreRecordCollection.cs b/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/IVectorStoreRecordCollection.cs
index 97e898fd7b56..84acae5bb6d2 100644
--- a/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/IVectorStoreRecordCollection.cs
+++ b/dotnet/src/Connectors/VectorData.Abstractions/VectorStorage/IVectorStoreRecordCollection.cs
@@ -25,7 +25,7 @@ public interface IVectorStoreRecordCollection<TKey, TRecord> : IVectorizedSearch
     /// <summary>
     /// Gets the name of the collection.
     /// </summary>
-    string CollectionName { get; }
+    string Name { get; }
 
     /// <summary>
     /// Checks if the collection exists in the vector store.