diff --git a/docs/configuration.md b/docs/configuration.md
index ef7847e60..b20865339 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -21,7 +21,7 @@ public static void RegisterInContainer<TDbContext>(
         IServiceCollection services,
         ResolveDbContext<TDbContext>? resolveDbContext = null,
         IModel? model = null,
-        ResolveFilters? resolveFilters = null,
+        ResolveFilters<TDbContext>? resolveFilters = null,
         bool disableTracking = false,
         bool disableAsync = false)
 ```
@@ -92,9 +92,10 @@ A delegate that resolves the [Filters](filters.md).
 ```cs
 namespace GraphQL.EntityFramework;
 
-public delegate Filters? ResolveFilters(object userContext);
+public delegate Filters<TDbContext>? ResolveFilters<TDbContext>(object userContext)
+    where TDbContext : DbContext;
 ```
-<sup><a href='/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs#L1-L3' title='Snippet source file'>snippet source</a> | <a href='#snippet-ResolveFilters.cs' title='Start of snippet'>anchor</a></sup>
+<sup><a href='/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs#L1-L4' title='Snippet source file'>snippet source</a> | <a href='#snippet-ResolveFilters.cs' title='Start of snippet'>anchor</a></sup>
 <!-- endSnippet -->
 
 It has access to the current GraphQL user context.
@@ -121,7 +122,7 @@ public static void RegisterInContainer<TDbContext>(
         IServiceCollection services,
         ResolveDbContext<TDbContext>? resolveDbContext = null,
         IModel? model = null,
-        ResolveFilters? resolveFilters = null,
+        ResolveFilters<TDbContext>? resolveFilters = null,
         bool disableTracking = false,
         bool disableAsync = false)
 ```
diff --git a/docs/filters.md b/docs/filters.md
index 21dffad3e..435e86902 100644
--- a/docs/filters.md
+++ b/docs/filters.md
@@ -26,15 +26,16 @@ Notes:
 <!-- snippet: FiltersSignature -->
 <a id='snippet-FiltersSignature'></a>
 ```cs
-public class Filters
+public class Filters<TDbContext>
+    where TDbContext : DbContext
 {
-    public delegate bool Filter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
+    public delegate bool Filter<in TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 
-    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
+    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 ```
-<sup><a href='/src/GraphQL.EntityFramework/Filters/Filters.cs#L3-L13' title='Snippet source file'>snippet source</a> | <a href='#snippet-FiltersSignature' title='Start of snippet'>anchor</a></sup>
+<sup><a href='/src/GraphQL.EntityFramework/Filters/Filters.cs#L3-L14' title='Snippet source file'>snippet source</a> | <a href='#snippet-FiltersSignature' title='Start of snippet'>anchor</a></sup>
 <!-- endSnippet -->
 
 
@@ -51,9 +52,9 @@ public class MyEntity
 <sup><a href='/src/Snippets/GlobalFilterSnippets.cs#L5-L12' title='Snippet source file'>snippet source</a> | <a href='#snippet-add-filter' title='Start of snippet'>anchor</a></sup>
 <a id='snippet-add-filter-1'></a>
 ```cs
-var filters = new Filters();
+var filters = new Filters<MyDbContext>();
 filters.Add<MyEntity>(
-    (userContext, userPrincipal, item) => item.Property != "Ignore");
+    (userContext, date, userPrincipal, item) => item.Property != "Ignore");
 EfGraphQLConventions.RegisterInContainer<MyDbContext>(
     services,
     resolveFilters: _ => filters);
diff --git a/src/GraphQL.EntityFramework/ConnectionConverter.cs b/src/GraphQL.EntityFramework/ConnectionConverter.cs
index 9765acd6b..80302220a 100644
--- a/src/GraphQL.EntityFramework/ConnectionConverter.cs
+++ b/src/GraphQL.EntityFramework/ConnectionConverter.cs
@@ -68,7 +68,7 @@ static Connection<T> Range<T>(
         return Build(skip, take, count, page);
     }
 
-    public static Task<Connection<TItem>> ApplyConnectionContext<TSource, TItem>(
+    public static Task<Connection<TItem>> ApplyConnectionContext<TDbContext, TSource, TItem>(
         this IQueryable<TItem> queryable,
         int? first,
         string afterString,
@@ -76,23 +76,27 @@ public static Task<Connection<TItem>> ApplyConnectionContext<TSource, TItem>(
         string beforeString,
         IResolveFieldContext<TSource> context,
         Cancel cancel,
-        Filters filters)
+        Filters<TDbContext>? filters,
+        TDbContext data)
         where TItem : class
+        where TDbContext : DbContext
     {
         Parse(afterString, beforeString, out var after, out var before);
-        return ApplyConnectionContext(queryable, first, after, last, before, context, filters, cancel);
+        return ApplyConnectionContext(queryable, first, after, last, before, context, filters, cancel, data);
     }
 
-    public static async Task<Connection<TItem>> ApplyConnectionContext<TSource, TItem>(
+    public static async Task<Connection<TItem>> ApplyConnectionContext<TDbContext, TSource, TItem>(
         IQueryable<TItem> queryable,
         int? first,
         int? after,
         int? last,
         int? before,
         IResolveFieldContext<TSource> context,
-        Filters filters,
-        Cancel cancel = default)
+        Filters<TDbContext>? filters,
+        Cancel cancel,
+        TDbContext data)
         where TItem : class
+        where TDbContext : DbContext
     {
         if (queryable is not IOrderedQueryable<TItem>)
         {
@@ -102,22 +106,24 @@ public static async Task<Connection<TItem>> ApplyConnectionContext<TSource, TIte
         cancel.ThrowIfCancellationRequested();
         if (last is null)
         {
-            return await First(queryable, first.GetValueOrDefault(0), after, before, count, context, filters, cancel);
+            return await First(queryable, first.GetValueOrDefault(0), after, before, count, context, filters, cancel, data);
         }
 
-        return await Last(queryable, last.Value, after, before, count, context, filters, cancel);
+        return await Last(queryable, last.Value, after, before, count, context, filters, cancel, data);
     }
 
-    static Task<Connection<TItem>> First<TSource, TItem>(
+    static Task<Connection<TItem>> First<TDbContext, TSource, TItem>(
         IQueryable<TItem> queryable,
         int first,
         int? after,
         int? before,
         int count,
         IResolveFieldContext<TSource> context,
-        Filters filters,
-        Cancel cancel)
+        Filters<TDbContext>? filters,
+        Cancel cancel,
+        TDbContext data)
         where TItem : class
+        where TDbContext : DbContext
     {
         int skip;
         if (before is null)
@@ -129,19 +135,21 @@ static Task<Connection<TItem>> First<TSource, TItem>(
             skip = Math.Max(before.Value - first, 0);
         }
 
-        return Range(queryable, skip, first, count, context, filters, cancel);
+        return Range(queryable, skip, first, count, context, filters, cancel, data);
     }
 
-    static Task<Connection<TItem>> Last<TSource, TItem>(
+    static Task<Connection<TItem>> Last<TDbContext, TSource, TItem>(
         IQueryable<TItem> queryable,
         int last,
         int? after,
         int? before,
         int count,
         IResolveFieldContext<TSource> context,
-        Filters filters,
-        Cancel cancel)
+        Filters<TDbContext>? filters,
+        Cancel cancel,
+        TDbContext data)
         where TItem : class
+        where TDbContext : DbContext
     {
         int skip;
         if (after is null)
@@ -155,23 +163,28 @@ static Task<Connection<TItem>> Last<TSource, TItem>(
             skip = after.Value + 1;
         }
 
-        return Range(queryable, skip, take: last, count, context, filters, cancel);
+        return Range(queryable, skip, take: last, count, context, filters, cancel, data);
     }
 
-    static async Task<Connection<TItem>> Range<TSource, TItem>(
+    static async Task<Connection<TItem>> Range<TDbContext, TSource, TItem>(
         IQueryable<TItem> queryable,
         int skip,
         int take,
         int count,
         IResolveFieldContext<TSource> context,
-        Filters filters,
-        Cancel cancel)
+        Filters<TDbContext>? filters,
+        Cancel cancel,
+        TDbContext data)
         where TItem : class
+        where TDbContext : DbContext
     {
         var page = queryable.Skip(skip).Take(take);
         QueryLogger.Write(page);
         IEnumerable<TItem> result = await page.ToListAsync(cancel);
-        result = await filters.ApplyFilter(result, context.UserContext, context.User);
+        if (filters != null)
+        {
+            result = await filters.ApplyFilter(result, context.UserContext, data, context.User);
+        }
 
         cancel.ThrowIfCancellationRequested();
         return Build(skip, take, count, result);
diff --git a/src/GraphQL.EntityFramework/EfGraphQLConventions.cs b/src/GraphQL.EntityFramework/EfGraphQLConventions.cs
index a42beb3de..215d2e0b9 100644
--- a/src/GraphQL.EntityFramework/EfGraphQLConventions.cs
+++ b/src/GraphQL.EntityFramework/EfGraphQLConventions.cs
@@ -17,7 +17,7 @@ public static void RegisterInContainer<TDbContext>(
             IServiceCollection services,
             ResolveDbContext<TDbContext>? resolveDbContext = null,
             IModel? model = null,
-            ResolveFilters? resolveFilters = null,
+            ResolveFilters<TDbContext>? resolveFilters = null,
             bool disableTracking = false,
             bool disableAsync = false)
 
@@ -37,14 +37,14 @@ public static void RegisterInContainer<TDbContext>(
     static EfGraphQLService<TDbContext> Build<TDbContext>(
         ResolveDbContext<TDbContext>? dbContextResolver,
         IModel? model,
-        ResolveFilters? filters,
+        ResolveFilters<TDbContext>? filters,
         IServiceProvider provider,
         bool disableTracking,
         bool disableAsync)
         where TDbContext : DbContext
     {
         model ??= ResolveModel<TDbContext>(provider);
-        filters ??= provider.GetService<ResolveFilters>();
+        filters ??= provider.GetService<ResolveFilters<TDbContext>>();
         dbContextResolver ??= _ => DbContextFromProvider<TDbContext>(provider);
 
         return new(
diff --git a/src/GraphQL.EntityFramework/Filters/Filters.cs b/src/GraphQL.EntityFramework/Filters/Filters.cs
index c24e9f084..7a29a8c9f 100644
--- a/src/GraphQL.EntityFramework/Filters/Filters.cs
+++ b/src/GraphQL.EntityFramework/Filters/Filters.cs
@@ -2,12 +2,13 @@
 
 #region FiltersSignature
 
-public class Filters
+public class Filters<TDbContext>
+    where TDbContext : DbContext
 {
-    public delegate bool Filter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
+    public delegate bool Filter<in TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 
-    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity input)
+    public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity input)
         where TEntity : class;
 
     #endregion
@@ -15,11 +16,11 @@ public delegate Task<bool> AsyncFilter<in TEntity>(object userContext, ClaimsPri
     public void Add<TEntity>(Filter<TEntity> filter)
         where TEntity : class =>
         funcs[typeof(TEntity)] =
-            (userContext, userPrincipal, item) =>
+            (userContext, data, userPrincipal, item) =>
             {
                 try
                 {
-                    return Task.FromResult(filter(userContext, userPrincipal, (TEntity) item));
+                    return Task.FromResult(filter(userContext, data, userPrincipal, (TEntity) item));
                 }
                 catch (Exception exception)
                 {
@@ -30,11 +31,11 @@ public void Add<TEntity>(Filter<TEntity> filter)
     public void Add<TEntity>(AsyncFilter<TEntity> filter)
         where TEntity : class =>
         funcs[typeof(TEntity)] =
-            async (userContext, userPrincipal, item) =>
+            async (userContext, data, userPrincipal, item) =>
             {
                 try
                 {
-                    return await filter(userContext, userPrincipal, (TEntity) item);
+                    return await filter(userContext, data, userPrincipal, (TEntity) item);
                 }
                 catch (Exception exception)
                 {
@@ -42,11 +43,11 @@ public void Add<TEntity>(AsyncFilter<TEntity> filter)
                 }
             };
 
-    delegate Task<bool> Filter(object userContext, ClaimsPrincipal? userPrincipal, object input);
+    delegate Task<bool> Filter(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, object input);
 
     Dictionary<Type, Filter> funcs = [];
 
-    internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, ClaimsPrincipal? userPrincipal)
+    internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, TDbContext data, ClaimsPrincipal? userPrincipal)
         where TEntity : class
     {
         if (funcs.Count == 0)
@@ -63,7 +64,7 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab
         var list = new List<TEntity>();
         foreach (var item in result)
         {
-            if (await ShouldInclude(userContext, userPrincipal, item, filters))
+            if (await ShouldInclude(userContext, data, userPrincipal, item, filters))
             {
                 list.Add(item);
             }
@@ -72,12 +73,12 @@ internal virtual async Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerab
         return list;
     }
 
-    static async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity item, List<AsyncFilter<TEntity>> filters)
+    static async Task<bool> ShouldInclude<TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity item, List<AsyncFilter<TEntity>> filters)
         where TEntity : class
     {
         foreach (var func in filters)
         {
-            if (!await func(userContext, userPrincipal, item))
+            if (!await func(userContext, data, userPrincipal, item))
             {
                 return false;
             }
@@ -86,7 +87,7 @@ static async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincip
         return true;
     }
 
-    internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity? item)
+    internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, TDbContext data, ClaimsPrincipal? userPrincipal, TEntity? item)
         where TEntity : class
     {
         if (item is null)
@@ -101,7 +102,7 @@ internal virtual async Task<bool> ShouldInclude<TEntity>(object userContext, Cla
 
         foreach (var func in FindFilters<TEntity>())
         {
-            if (!await func(userContext, userPrincipal, item))
+            if (!await func(userContext, data, userPrincipal, item))
             {
                 return false;
             }
@@ -116,7 +117,7 @@ IEnumerable<AsyncFilter<TEntity>> FindFilters<TEntity>()
         var type = typeof(TEntity);
         foreach (var pair in funcs.Where(_ => _.Key.IsAssignableFrom(type)))
         {
-            yield return (context, user, item) => pair.Value(context, user, item);
+            yield return (context, data, user, item) => pair.Value(context, data, user, item);
         }
     }
 }
\ No newline at end of file
diff --git a/src/GraphQL.EntityFramework/Filters/NullFilters.cs b/src/GraphQL.EntityFramework/Filters/NullFilters.cs
deleted file mode 100644
index db034f4f5..000000000
--- a/src/GraphQL.EntityFramework/Filters/NullFilters.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-namespace GraphQL.EntityFramework;
-
-public class NullFilters :
-    Filters
-{
-    public static NullFilters Instance = new();
-
-    internal override Task<IEnumerable<TEntity>> ApplyFilter<TEntity>(IEnumerable<TEntity> result, object userContext, ClaimsPrincipal? userPrincipal) =>
-        Task.FromResult(result);
-
-    internal override Task<bool> ShouldInclude<TEntity>(object userContext, ClaimsPrincipal? userPrincipal, TEntity? item)
-        where TEntity : class =>
-        Task.FromResult(true);
-}
\ No newline at end of file
diff --git a/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs b/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs
index d5c7b7344..a3b487cee 100644
--- a/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs
+++ b/src/GraphQL.EntityFramework/Filters/ResolveFilters.cs
@@ -1,3 +1,4 @@
 namespace GraphQL.EntityFramework;
 
-public delegate Filters? ResolveFilters(object userContext);
\ No newline at end of file
+public delegate Filters<TDbContext>? ResolveFilters<TDbContext>(object userContext)
+    where TDbContext : DbContext;
\ No newline at end of file
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService.cs
index d38088adb..82927cffe 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService.cs
@@ -4,7 +4,7 @@ public partial class EfGraphQLService<TDbContext> :
     IEfGraphQLService<TDbContext>
     where TDbContext : DbContext
 {
-    ResolveFilters? resolveFilters;
+    ResolveFilters<TDbContext>? resolveFilters;
     bool disableTracking;
     bool disableAsync;
     ResolveDbContext<TDbContext> resolveDbContext;
@@ -14,7 +14,7 @@ public partial class EfGraphQLService<TDbContext> :
     public EfGraphQLService(
         IModel model,
         ResolveDbContext<TDbContext> resolveDbContext,
-        ResolveFilters? resolveFilters = null,
+        ResolveFilters<TDbContext>? resolveFilters = null,
         bool disableTracking = false,
         bool disableAsync = false)
     {
@@ -68,11 +68,8 @@ ResolveEfFieldContext<TDbContext, TSource> BuildContext<TSource>(
     public TDbContext ResolveDbContext(IResolveFieldContext context) =>
         resolveDbContext(context.UserContext);
 
-    Filters ResolveFilter<TSource>(IResolveFieldContext<TSource> context)
-    {
-        var filter = resolveFilters?.Invoke(context.UserContext);
-        return filter ?? NullFilters.Instance;
-    }
+    Filters<TDbContext>? ResolveFilter<TSource>(IResolveFieldContext<TSource> context) =>
+        resolveFilters?.Invoke(context.UserContext);
 
     public IQueryable<TItem> AddIncludes<TItem>(IQueryable<TItem> query, IResolveFieldContext context)
         where TItem : class =>
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_First.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_First.cs
index 4bbc5322d..40f580ed5 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_First.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_First.cs
@@ -195,7 +195,8 @@ FieldType BuildFirstField<TSource, TReturn>(
 
                 if (first is not null)
                 {
-                    if (await efFieldContext.Filters.ShouldInclude(context.UserContext, context.User, first))
+                    if (efFieldContext.Filters == null ||
+                        await efFieldContext.Filters.ShouldInclude(context.UserContext, efFieldContext.DbContext, context.User, first))
                     {
                         if (mutate is not null)
                         {
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs
index bd8bd6696..5cf0daf1a 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Navigation.cs
@@ -46,7 +46,8 @@ public FieldBuilder<TSource, TReturn> AddNavigationField<TSource, TReturn>(
                             exception);
                     }
 
-                    if (await fieldContext.Filters.ShouldInclude(context.UserContext, context.User, result))
+                    if (fieldContext.Filters == null ||
+                        await fieldContext.Filters.ShouldInclude(context.UserContext, fieldContext.DbContext, context.User, result))
                     {
                         return result;
                     }
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs
index 1dc9aa7d1..135ef051f 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationConnection.cs
@@ -99,7 +99,11 @@ ConnectionBuilder<TSource> AddEnumerableConnection<TSource, TGraph, TReturn>(
                 }
 
                 enumerable = enumerable.ApplyGraphQlArguments(hasId, context, omitQueryArguments);
-                enumerable = await efFieldContext.Filters.ApplyFilter(enumerable, context.UserContext, context.User);
+                if (efFieldContext.Filters != null)
+                {
+                    enumerable = await efFieldContext.Filters.ApplyFilter(enumerable, context.UserContext, efFieldContext.DbContext, context.User);
+                }
+
                 var page = enumerable.ToList();
 
                 return ConnectionConverter.ApplyConnectionContext(
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs
index 3dbed079b..3856980e1 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_NavigationList.cs
@@ -25,20 +25,24 @@ public FieldBuilder<TSource, TReturn> AddNavigationListField<TSource, TReturn>(
 
         if (resolve is not null)
         {
-            field.Resolver = new FuncFieldResolver<TSource, IEnumerable<TReturn>>(
-                async context =>
+            field.Resolver = new FuncFieldResolver<TSource, IEnumerable<TReturn>>(async context =>
+            {
+                var fieldContext = BuildContext(context);
+                var result = resolve(fieldContext);
+
+                if (result is IQueryable)
                 {
-                    var fieldContext = BuildContext(context);
-                    var result = resolve(fieldContext);
+                    throw new("This API expects the resolver to return a IEnumerable, not an IQueryable. Instead use AddQueryField.");
+                }
 
-                    if (result is IQueryable)
-                    {
-                        throw new("This API expects the resolver to return a IEnumerable, not an IQueryable. Instead use AddQueryField.");
-                    }
+                result = result.ApplyGraphQlArguments(hasId, context, omitQueryArguments);
+                if (fieldContext.Filters == null)
+                {
+                    return result;
+                }
 
-                    result = result.ApplyGraphQlArguments(hasId, context, omitQueryArguments);
-                    return await fieldContext.Filters.ApplyFilter(result, context.UserContext, context.User);
-                });
+                return await fieldContext.Filters.ApplyFilter(result, context.UserContext, fieldContext.DbContext, context.User);
+            });
         }
 
         graph.AddField(field);
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs
index 7e9f1cb07..b67ded24e 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Queryable.cs
@@ -144,7 +144,12 @@ FieldType BuildQueryField<TSource, TReturn>(
                             exception);
                     }
 
-                    return await fieldContext.Filters.ApplyFilter(list, context.UserContext, context.User);
+                    if (fieldContext.Filters == null)
+                    {
+                        return list;
+                    }
+
+                    return await fieldContext.Filters.ApplyFilter(list, context.UserContext, fieldContext.DbContext, context.User);
                 });
         }
 
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_QueryableConnection.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_QueryableConnection.cs
index f5299e296..c4ba3e4a9 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_QueryableConnection.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_QueryableConnection.cs
@@ -156,7 +156,8 @@ ConnectionBuilder<TSource> AddQueryableConnection<TSource, TGraph, TReturn>(
                                 context.Before!,
                                 context,
                                 context.CancellationToken,
-                                efFieldContext.Filters);
+                                efFieldContext.Filters,
+                                efFieldContext.DbContext);
                     }
                     catch (TaskCanceledException)
                     {
diff --git a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs
index 4e6c9a266..50b894d62 100644
--- a/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/EfGraphQLService_Single.cs
@@ -196,7 +196,8 @@ FieldType BuildSingleField<TSource, TReturn>(
 
                     if (single is not null)
                     {
-                        if (await efFieldContext.Filters.ShouldInclude(context.UserContext, context.User, single))
+                        if (efFieldContext.Filters == null ||
+                            await efFieldContext.Filters.ShouldInclude(context.UserContext, efFieldContext.DbContext, context.User, single))
                         {
                             if (mutate is not null)
                             {
diff --git a/src/GraphQL.EntityFramework/GraphApi/ResolveEfFieldContext.cs b/src/GraphQL.EntityFramework/GraphApi/ResolveEfFieldContext.cs
index f16ba29e2..59000944d 100644
--- a/src/GraphQL.EntityFramework/GraphApi/ResolveEfFieldContext.cs
+++ b/src/GraphQL.EntityFramework/GraphApi/ResolveEfFieldContext.cs
@@ -5,5 +5,5 @@ public class ResolveEfFieldContext<TDbContext, TSource> :
     where TDbContext : DbContext
 {
     public TDbContext DbContext { get; set; } = null!;
-    public Filters Filters { get; set; } = null!;
+    public Filters<TDbContext>? Filters { get; set; }
 }
\ No newline at end of file
diff --git a/src/Snippets/GlobalFilterSnippets.cs b/src/Snippets/GlobalFilterSnippets.cs
index 0eb5b1466..9c182513d 100644
--- a/src/Snippets/GlobalFilterSnippets.cs
+++ b/src/Snippets/GlobalFilterSnippets.cs
@@ -15,9 +15,9 @@ public static void Add(ServiceCollection services)
     {
         #region add-filter
 
-        var filters = new Filters();
+        var filters = new Filters<MyDbContext>();
         filters.Add<MyEntity>(
-            (userContext, userPrincipal, item) => item.Property != "Ignore");
+            (userContext, date, userPrincipal, item) => item.Property != "Ignore");
         EfGraphQLConventions.RegisterInContainer<MyDbContext>(
             services,
             resolveFilters: _ => filters);
diff --git a/src/Tests/ConnectionConverter/ConnectionConverterTests.cs b/src/Tests/ConnectionConverter/ConnectionConverterTests.cs
index 586e760c3..28c2a2473 100644
--- a/src/Tests/ConnectionConverter/ConnectionConverterTests.cs
+++ b/src/Tests/ConnectionConverter/ConnectionConverterTests.cs
@@ -42,7 +42,7 @@ public async Task Queryable(int? first, int? after, int? last, int? before)
         var fieldContext = new ResolveFieldContext<string>();
         await using var database = await sqlInstance.Build(databaseSuffix: $"{first.GetValueOrDefault(0)}{after.GetValueOrDefault(0)}{last.GetValueOrDefault(0)}{before.GetValueOrDefault(0)}");
         var entities = database.Context.Entities;
-        var connection = await ConnectionConverter.ApplyConnectionContext<string, Entity>(entities.OrderBy(x=>x.Property), first, after, last, before, fieldContext, new());
+        var connection = await ConnectionConverter.ApplyConnectionContext<MyContext, string, Entity>(entities.OrderBy(x=>x.Property), first, after, last, before, fieldContext, new(), Cancel.None,database.Context);
         await Verify(connection.Items!.OrderBy(_ => _!.Property))
             .UseParameters(first, after, last, before);
     }
diff --git a/src/Tests/GlobalFiltersTests.cs b/src/Tests/GlobalFiltersTests.cs
index db7ae45f8..56b87074a 100644
--- a/src/Tests/GlobalFiltersTests.cs
+++ b/src/Tests/GlobalFiltersTests.cs
@@ -1,30 +1,30 @@
-using Filters = GraphQL.EntityFramework.Filters;
-
-public class GlobalFiltersTests
+public class GlobalFiltersTests
 {
     [Fact]
     public async Task Simple()
     {
-        var filters= new Filters();
-        filters.Add<Target>((_, _, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), null, new Target()));
-        Assert.False(await filters.ShouldInclude<object>(new(), null, null));
-        Assert.True(await filters.ShouldInclude(new(), null, new Target {Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), null, new Target {Property = "Ignore"}));
-
-        filters.Add<BaseTarget>((_, _, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), null, new ChildTarget()));
-        Assert.True(await filters.ShouldInclude(new(), null, new ChildTarget {Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), null, new ChildTarget {Property = "Ignore"}));
-
-        filters.Add<ITarget>((_, _, target) => target.Property != "Ignore");
-        Assert.True(await filters.ShouldInclude(new(), null, new ImplementationTarget()));
-        Assert.True(await filters.ShouldInclude(new(), null, new ImplementationTarget { Property = "Include"}));
-        Assert.False(await filters.ShouldInclude(new(), null, new ImplementationTarget { Property = "Ignore" }));
-
-        Assert.True(await filters.ShouldInclude(new(), null, new NonTarget { Property = "Foo" }));
+        var filters = new Filters<MyContext>();
+        filters.Add<Target>((_, _, _, target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new Target()));
+        Assert.False(await filters.ShouldInclude<object>(new(), new(), null, null));
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new Target {Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), new(), null, new Target {Property = "Ignore"}));
+
+        filters.Add<BaseTarget>((_, _, _,  target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new ChildTarget()));
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new ChildTarget {Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), new(), null, new ChildTarget {Property = "Ignore"}));
+
+        filters.Add<ITarget>((_, _, _,  target) => target.Property != "Ignore");
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new ImplementationTarget()));
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new ImplementationTarget { Property = "Include"}));
+        Assert.False(await filters.ShouldInclude(new(), new(), null, new ImplementationTarget { Property = "Ignore" }));
+
+        Assert.True(await filters.ShouldInclude(new(), new(), null, new NonTarget { Property = "Foo" }));
     }
 
+    public class MyContext : DbContext;
+
     public class NonTarget
     {
         public string? Property { get; set; }
diff --git a/src/Tests/IntegrationTests/IntegrationTests.cs b/src/Tests/IntegrationTests/IntegrationTests.cs
index c6858e723..99e755dd8 100644
--- a/src/Tests/IntegrationTests/IntegrationTests.cs
+++ b/src/Tests/IntegrationTests/IntegrationTests.cs
@@ -1,5 +1,3 @@
-using Filters = GraphQL.EntityFramework.Filters;
-
 public partial class IntegrationTests
 {
     static SqlInstance<IntegrationDbContext> sqlInstance;
@@ -3008,7 +3006,7 @@ static async Task RunQuery(
         SqlDatabase<IntegrationDbContext> database,
         string query,
         Inputs? inputs,
-        Filters? filters,
+        Filters<IntegrationDbContext>? filters,
         bool disableTracking,
         object[] entities,
         bool disableAsync = false,
diff --git a/src/Tests/IntegrationTests/IntegrationTests_filtered.cs b/src/Tests/IntegrationTests/IntegrationTests_filtered.cs
index 0bd9f26c3..1717bc7c9 100644
--- a/src/Tests/IntegrationTests/IntegrationTests_filtered.cs
+++ b/src/Tests/IntegrationTests/IntegrationTests_filtered.cs
@@ -1,6 +1,4 @@
-using Filters = GraphQL.EntityFramework.Filters;
-
-public partial class IntegrationTests
+public partial class IntegrationTests
 {
     [Fact]
     public async Task Child_filtered()
@@ -39,11 +37,11 @@ public async Task Child_filtered()
         await RunQuery(database, query, null, BuildFilters(), false, [entity1, entity2, entity3]);
     }
 
-    static Filters BuildFilters()
+    static Filters<IntegrationDbContext> BuildFilters()
     {
-        var filters = new Filters();
-        filters.Add<FilterParentEntity>((_, _, item) => item.Property != "Ignore");
-        filters.Add<FilterChildEntity>((_, _, item) => item.Property != "Ignore");
+        var filters = new Filters<IntegrationDbContext>();
+        filters.Add<FilterParentEntity>((_, _, _, item) => item.Property != "Ignore");
+        filters.Add<FilterChildEntity>((_, _, _, item) => item.Property != "Ignore");
         return filters;
     }
 
diff --git a/src/Tests/IntegrationTests/QueryExecutor.cs b/src/Tests/IntegrationTests/QueryExecutor.cs
index 3c79e8447..6fbcc782b 100644
--- a/src/Tests/IntegrationTests/QueryExecutor.cs
+++ b/src/Tests/IntegrationTests/QueryExecutor.cs
@@ -5,7 +5,7 @@ public static async Task<string> ExecuteQuery<TDbContext>(
         ServiceCollection services,
         TDbContext data,
         Inputs? inputs,
-        Filters? filters,
+        Filters<TDbContext>? filters,
         bool disableTracking,
         bool disableAsync)
         where TDbContext : DbContext