Bump version to 10.0.1 and refactor graph store registration methods to remove MakeDefault options

Author: KSemenenko

AGENTS.md

@@ -10,6 +10,8 @@
 - Always run `dotnet test GraphRag.slnx` before finishing work, after building.
 - Avoid per-client connection locks (e.g., `_connectionLock` in `AgeClient`); rely on the smart connection manager for concurrency.
 - When initialization logic is required (initialization tasks), add a simple hosted service to perform it and register that hosted service inside the relevant extensions.
+- Do not expose user-facing knobs for AGE/Postgres connection pool sizing (e.g., `MaxConnections` parameters); rely on EF Core-style connection-string keywords and reasonable defaults inside the connector.
+- Graph store registrations (Postgres, Neo4j, Cosmos) must automatically register a default `IGraphStore`; remove `MakeDefault` toggles/options and rely on the first registration when an unkeyed graph store is requested.
 
 # Conversations
 any resulting updates to agents.md should go under the section "## Rules to follow"

Directory.Build.props

@@ -25,8 +25,8 @@
         <RepositoryUrl>https://github.com/managedcode/graphrag</RepositoryUrl>
         <PackageProjectUrl>https://github.com/managedcode/graphrag</PackageProjectUrl>
         <Product>Managed Code GraphRag</Product>
-        <Version>10.0.0</Version>
-        <PackageVersion>10.0.0</PackageVersion>
+        <Version>10.0.1</Version>
+        <PackageVersion>10.0.1</PackageVersion>
 
     </PropertyGroup>
     <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">

README.md

@@ -205,7 +205,11 @@ dotnet test tests/ManagedCode.GraphRag.Tests/ManagedCode.GraphRag.Tests.csproj \
 
 ---
 
-## Apache AGE / PostgreSQL Setup
+## Graph Store Configuration
+
+GraphRAG ships with adapters for Apache AGE/PostgreSQL, Neo4j, and Azure Cosmos DB. Every adapter registers keyed services so you can address a specific store via `GetRequiredKeyedService<IGraphStore>("postgres")`, while the first registered store automatically becomes the unkeyed default (`GetRequiredService<IGraphStore>()`). This mirrors EF Core’s “one default context” pattern and removes any extra `MakeDefault` toggles.
+
+### Apache AGE / PostgreSQL Setup
 
 GraphRAG ships with a first-class Apache AGE adapter (`ManagedCode.GraphRag.Postgres`). AGE is enabled on top of PostgreSQL, so you only need a standard Postgres instance with the AGE extension installed.
 
@@ -226,15 +230,57 @@ GraphRAG ships with a first-class Apache AGE adapter (`ManagedCode.GraphRag.Post
        "GraphStores": {
          "postgres": {
            "ConnectionString": "Host=localhost;Port=5432;Username=postgres;Password=postgres;Database=graphrag",
-           "GraphName": "graphrag",
-           "MaxConnections": 40,
-           "MakeDefault": true
+          "GraphName": "graphrag"
          }
        }
      }
    }
    ```
-4. **Register through DI.** `services.AddPostgresGraphStore("postgres", configure: ...)` wires up `IAgeConnectionManager`, `IAgeClientFactory`, and `IGraphStore` automatically. `MaxConnections` caps the number of concurrent AGE sessions (the default is 40 so you stay under the container’s `max_connections`).
+4. **Register through DI.** `services.AddPostgresGraphStore("postgres", configure: ...)` wires up `IAgeConnectionManager`, `IAgeClientFactory`, and `IGraphStore` automatically. Pool sizing behaves like EF Core—tune it via connection-string keywords such as `Maximum Pool Size` when needed, otherwise the standard Npgsql defaults apply. The first Postgres store you register becomes the default `IGraphStore`, and additional stores stay keyed-only:
+   ```csharp
+   await using var client = ageClientFactory.CreateClient();
+   await client.OpenConnectionAsync(cancellationToken);
+   ```
+
+### Neo4j Setup
+
+Neo4j support lives in `ManagedCode.GraphRag.Neo4j` and uses the official Bolt driver:
+
+1. **Run Neo4j locally (optional).**
+   ```bash
+   docker run --rm \
+     -e NEO4J_AUTH=neo4j/test1234 \
+     -e NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
+     -p 7687:7687 -p 7474:7474 \
+     neo4j:5.23.0-community
+   ```
+2. **Register the store.**
+   ```csharp
+   builder.Services.AddNeo4jGraphStore("neo4j", options =>
+   {
+       options.Uri = "bolt://localhost:7687";
+       options.Username = "neo4j";
+       options.Password = "test1234";
+   });
+   ```
+   The first Neo4j registration will automatically satisfy `IGraphStore`; use `GetRequiredKeyedService<IGraphStore>("neo4j")` for explicit access.
+
+### Azure Cosmos DB Setup
+
+The Cosmos adapter (`ManagedCode.GraphRag.CosmosDb`) targets the SQL API and works with the emulator or live accounts:
+
+1. **Provide a connection string.** Set `COSMOS_EMULATOR_CONNECTION_STRING` or configure options manually.
+2. **Register the store.**
+   ```csharp
+   builder.Services.AddCosmosGraphStore("cosmos", options =>
+   {
+       options.ConnectionString = cosmosConnectionString;
+       options.DatabaseId = "GraphRagIntegration";
+       options.NodesContainerId = "nodes";
+       options.EdgesContainerId = "edges";
+   });
+   ```
+   As with other adapters, the first Cosmos store becomes the unkeyed default.
 
 > **Tip:** `IGraphStore` now exposes `GetNodesAsync` and `GetRelationshipsAsync` in addition to the targeted APIs (`InitializeAsync`, `Upsert*`, `GetOutgoingRelationshipsAsync`). These use the new AGE-powered enumerations so you can inspect or export the full graph without dropping down to concrete implementations.
 

src/ManagedCode.GraphRag.CosmosDb/ServiceCollectionExtensions.cs

@@ -2,13 +2,14 @@
 using GraphRag.Graphs;
 using Microsoft.Azure.Cosmos;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 
 namespace GraphRag.Storage.Cosmos;
 
 public static class ServiceCollectionExtensions
 {
-    public static IServiceCollection AddCosmosGraphStore(this IServiceCollection services, string key, Action<CosmosGraphStoreOptions> configure, bool makeDefault = false)
+    public static IServiceCollection AddCosmosGraphStore(this IServiceCollection services, string key, Action<CosmosGraphStoreOptions> configure)
     {
         ArgumentNullException.ThrowIfNull(services);
         ArgumentException.ThrowIfNullOrWhiteSpace(key);
@@ -40,11 +41,8 @@ public static IServiceCollection AddCosmosGraphStore(this IServiceCollection ser
         });
         services.AddKeyedSingleton<IGraphStore>(key, (sp, serviceKey) => sp.GetRequiredKeyedService<CosmosGraphStore>(serviceKey));
 
-        if (makeDefault)
-        {
-            services.AddSingleton(sp => sp.GetRequiredKeyedService<CosmosGraphStore>(key));
-            services.AddSingleton<IGraphStore>(sp => sp.GetRequiredKeyedService<CosmosGraphStore>(key));
-        }
+        services.TryAddSingleton<CosmosGraphStore>(sp => sp.GetRequiredKeyedService<CosmosGraphStore>(key));
+        services.TryAddSingleton<IGraphStore>(sp => sp.GetRequiredKeyedService<CosmosGraphStore>(key));
 
         return services;
     }

src/ManagedCode.GraphRag.Neo4j/ServiceCollectionExtensions.cs

@@ -1,12 +1,13 @@
 using GraphRag.Graphs;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 
 namespace GraphRag.Storage.Neo4j;
 
 public static class ServiceCollectionExtensions
 {
-    public static IServiceCollection AddNeo4jGraphStore(this IServiceCollection services, string key, Action<Neo4jGraphStoreOptions> configure, bool makeDefault = false)
+    public static IServiceCollection AddNeo4jGraphStore(this IServiceCollection services, string key, Action<Neo4jGraphStoreOptions> configure)
     {
         ArgumentNullException.ThrowIfNull(services);
         ArgumentException.ThrowIfNullOrWhiteSpace(key);
@@ -24,11 +25,8 @@ public static IServiceCollection AddNeo4jGraphStore(this IServiceCollection serv
         });
         services.AddKeyedSingleton<IGraphStore>(key, (sp, serviceKey) => sp.GetRequiredKeyedService<Neo4jGraphStore>(serviceKey));
 
-        if (makeDefault)
-        {
-            services.AddSingleton(sp => sp.GetRequiredKeyedService<Neo4jGraphStore>(key));
-            services.AddSingleton<IGraphStore>(sp => sp.GetRequiredKeyedService<Neo4jGraphStore>(key));
-        }
+        services.TryAddSingleton<Neo4jGraphStore>(sp => sp.GetRequiredKeyedService<Neo4jGraphStore>(key));
+        services.TryAddSingleton<IGraphStore>(sp => sp.GetRequiredKeyedService<Neo4jGraphStore>(key));
 
         return services;
     }

src/ManagedCode.GraphRag.Postgres/ApacheAge/AgeClientFactory.cs

@@ -1,3 +1,4 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 
 namespace GraphRag.Storage.Postgres.ApacheAge;
@@ -7,7 +8,7 @@ public interface IAgeClientFactory
     AgeClient CreateClient();
 }
 
-internal sealed class AgeClientFactory(IAgeConnectionManager connectionManager, ILoggerFactory loggerFactory) : IAgeClientFactory
+internal sealed class AgeClientFactory([FromKeyedServices] IAgeConnectionManager connectionManager, ILoggerFactory loggerFactory) : IAgeClientFactory
 {
     private readonly IAgeConnectionManager _connectionManager = connectionManager ?? throw new ArgumentNullException(nameof(connectionManager));
     private readonly ILoggerFactory _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));

src/ManagedCode.GraphRag.Postgres/ApacheAge/AgeConnectionManager.cs

@@ -1,3 +1,4 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Npgsql;
@@ -18,19 +19,24 @@ public sealed class AgeConnectionManager : IAgeConnectionManager
     private volatile bool _extensionEnsured;
     private bool _disposed;
 
-    public AgeConnectionManager(string connectionString, ILogger<AgeConnectionManager>? logger = null, int maxPoolSize = 100)
+    [ActivatorUtilitiesConstructor]
+    public AgeConnectionManager(
+        [FromKeyedServices] PostgresGraphStoreOptions options,
+        ILogger<AgeConnectionManager>? logger = null)
+        : this(options?.ConnectionString ?? throw new ArgumentNullException(nameof(options)), logger)
+    {
+    }
+
+    public AgeConnectionManager(string connectionString, ILogger<AgeConnectionManager>? logger = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
-        if (maxPoolSize <= 0)
-        {
-            throw new ArgumentOutOfRangeException(nameof(maxPoolSize), "Max pool size must be greater than zero.");
-        }
 
-        var connectionBuilder = new NpgsqlConnectionStringBuilder(connectionString)
+        var connectionBuilder = new NpgsqlConnectionStringBuilder(connectionString);
+        if (connectionBuilder.MaxPoolSize <= 0)
         {
-            MaxPoolSize = maxPoolSize,
-            MinPoolSize = Math.Min(10, maxPoolSize)
-        };
+            throw new ArgumentOutOfRangeException(nameof(connectionString), "Maximum Pool Size must be greater than zero.");
+        }
+        connectionBuilder.MinPoolSize = Math.Min(10, connectionBuilder.MaxPoolSize);
 
         ConnectionString = connectionBuilder.ConnectionString;
         _dataSource = NpgsqlDataSource.Create(connectionBuilder.ConnectionString);

src/ManagedCode.GraphRag.Postgres/ApacheAge/Resolvers/AgtypeResolverFactory.cs

@@ -24,8 +24,11 @@ private class Resolver : IPgTypeInfoResolver
     {
         protected static DataTypeName AgtypeDataTypeName => new("ag_catalog.agtype");
 
-        private TypeInfoMappingCollection? _mappings;
-        protected TypeInfoMappingCollection Mappings => _mappings ??= AddMappings(new());
+        private static readonly Lazy<TypeInfoMappingCollection> ResolverMappings = new(static () => AddMappings(new()));
+
+        protected static TypeInfoMappingCollection BaseMappings => ResolverMappings.Value;
+
+        protected static TypeInfoMappingCollection Mappings => BaseMappings;
 
         public PgTypeInfo? GetTypeInfo(Type? type, DataTypeName? dataTypeName, PgSerializerOptions options)
             => Mappings.Find(type, dataTypeName, options);
@@ -41,8 +44,9 @@ private static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection m
 
     private sealed class ArrayResolver : Resolver, IPgTypeInfoResolver
     {
-        private TypeInfoMappingCollection? _mappings;
-        private new TypeInfoMappingCollection Mappings => _mappings ??= AddMappings(new(base.Mappings));
+        private static readonly Lazy<TypeInfoMappingCollection> ArrayMappings = new(static () => AddMappings(new(BaseMappings)));
+
+        private static new TypeInfoMappingCollection Mappings => ArrayMappings.Value;
 
         public new PgTypeInfo? GetTypeInfo(Type? type, DataTypeName? dataTypeName, PgSerializerOptions options)
             => Mappings.Find(type, dataTypeName, options);
@@ -56,4 +60,3 @@ private static TypeInfoMappingCollection AddMappings(TypeInfoMappingCollection m
     }
 }
 #pragma warning restore NPG9001 // Type is for evaluation purposes only and is subject to change or removal in future updates. Suppress this diagnostic to proceed.
-

src/ManagedCode.GraphRag.Postgres/PostgresGraphStore.cs

@@ -66,7 +66,7 @@ public PostgresGraphStore(PostgresGraphStoreOptions options, ILogger<PostgresGra
         {
             var factory = loggerFactory ?? NullLoggerFactory.Instance;
             var connectionManagerLogger = factory.CreateLogger<AgeConnectionManager>();
-            var connectionManager = new AgeConnectionManager(connectionString, connectionManagerLogger, options.MaxConnections);
+            var connectionManager = new AgeConnectionManager(connectionString, connectionManagerLogger);
             _ownedConnectionManager = connectionManager;
             _ageClientFactory = new AgeClientFactory(connectionManager, factory);
         }

src/ManagedCode.GraphRag.Postgres/PostgresGraphStoreConfig.cs

@@ -12,6 +12,4 @@ public sealed class PostgresGraphStoreConfig
 
     public Dictionary<string, string[]> EdgePropertyIndexes { get; set; } = new(StringComparer.OrdinalIgnoreCase);
 
-    public bool MakeDefault { get; set; }
-
 }