diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EdgesDataFetcherImpl.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EdgesDataFetcherImpl.java
new file mode 100644
index 00000000..9b116665
--- /dev/null
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/EdgesDataFetcherImpl.java
@@ -0,0 +1,55 @@
+package org.hypertrace.graphql.entity.dao;
+
+import graphql.schema.DataFetcher;
+import graphql.schema.DataFetchingEnvironment;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
+import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer;
+import org.hypertrace.graphql.entity.schema.EdgeResultSet;
+import org.hypertrace.graphql.entity.schema.Entity;
+import org.hypertrace.graphql.entity.schema.EntityType;
+import org.hypertrace.graphql.entity.schema.argument.NeighborEntityScopeArgument;
+import org.hypertrace.graphql.entity.schema.argument.NeighborEntityTypeArgument;
+
+abstract class EdgesDataFetcherImpl implements DataFetcher<CompletableFuture<EdgeResultSet>> {
+
+  private final ArgumentDeserializer argumentDeserializer;
+
+  protected abstract EdgeResultSet getEdges(
+      Entity entity, EntityType neighborType, String neighborScope, List<FilterArgument> filterBy);
+
+  EdgesDataFetcherImpl(ArgumentDeserializer argumentDeserializer) {
+    this.argumentDeserializer = argumentDeserializer;
+  }
+
+  @Override
+  public CompletableFuture<EdgeResultSet> get(DataFetchingEnvironment environment) {
+    // TODO: Edges when used with filters have two limitations for now
+    // 1. We can only have one entityType incoming/outgoing edge
+    // 2. If different filters for same entity type, filters will be merged into one AND filter.
+    //
+    // We are passing the empty filter as argument to query the edges.
+    // This will work for now because we have restricted multiple edges selection in a request
+    // Fix this when we will solve the above two limitations.
+    return CompletableFuture.completedFuture(
+        getEdges(
+            environment.getSource(),
+            getNeighborEntityType(environment.getArguments()).orElse(null),
+            getNeighborEntityScope(environment.getArguments()).orElse(null),
+            Collections.emptyList()));
+  }
+
+  private Optional<String> getNeighborEntityScope(Map<String, Object> arguments) {
+    return this.argumentDeserializer.deserializePrimitive(
+        arguments, NeighborEntityScopeArgument.class);
+  }
+
+  private Optional<EntityType> getNeighborEntityType(Map<String, Object> arguments) {
+    return this.argumentDeserializer.deserializePrimitive(
+        arguments, NeighborEntityTypeArgument.class);
+  }
+}
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java
index c8b5d183..81e18ee3 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityConverter.java
@@ -16,6 +16,7 @@
 import lombok.experimental.Accessors;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
 import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.common.utils.BiConverter;
 import org.hypertrace.core.graphql.common.utils.TriConverter;
 import org.hypertrace.gateway.service.v1.baseline.BaselineEntitiesResponse;
@@ -33,6 +34,7 @@
 import org.hypertrace.graphql.metric.schema.MetricContainer;
 
 class GatewayServiceEntityConverter {
+
   private final BiConverter<
           Collection<AttributeRequest>, Map<String, Value>, Map<AttributeExpression, Object>>
       attributeMapConverter;
@@ -143,6 +145,7 @@ private Single<Entity> convertEntity(
   @lombok.Value
   @Accessors(fluent = true)
   private static class ConvertedEntity implements Entity {
+
     String id;
     String type;
     Map<AttributeExpression, Object> attributeValues;
@@ -161,13 +164,15 @@ public MetricContainer metric(AttributeExpression attributeExpression) {
     }
 
     @Override
-    public EdgeResultSet incomingEdges(EntityType neighborType, String neighborScope) {
+    public EdgeResultSet incomingEdges(
+        EntityType neighborType, String neighborScope, List<FilterArgument> filterBy) {
       return this.incomingEdges.getOrDefault(
           this.resolveEntityScope(neighborType, neighborScope), EMPTY_EDGE_RESULT_SET);
     }
 
     @Override
-    public EdgeResultSet outgoingEdges(EntityType neighborType, String neighborScope) {
+    public EdgeResultSet outgoingEdges(
+        EntityType neighborType, String neighborScope, List<FilterArgument> filterBy) {
 
       return this.outgoingEdges.getOrDefault(
           this.resolveEntityScope(neighborType, neighborScope), EMPTY_EDGE_RESULT_SET);
@@ -188,6 +193,7 @@ private String resolveEntityScope(
   @lombok.Value
   @Accessors(fluent = true)
   private static class ConvertedEntityResultSet implements EntityResultSet {
+
     List<Entity> results;
     long total;
     long count;
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java
index 777344b4..d44cf876 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/GatewayServiceEntityInteractionRequestBuilder.java
@@ -7,6 +7,7 @@
 import java.util.Collection;
 import java.util.Set;
 import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import javax.inject.Inject;
 import lombok.Value;
 import lombok.experimental.Accessors;
@@ -25,6 +26,7 @@
 import org.hypertrace.graphql.metric.request.MetricAggregationRequest;
 
 class GatewayServiceEntityInteractionRequestBuilder {
+
   private static final Integer DEFAULT_INTERACTION_LIMIT = 1000;
   private final Converter<Collection<AttributeRequest>, Set<Expression>> selectionConverter;
   private final Converter<Collection<MetricAggregationRequest>, Set<Expression>>
@@ -48,7 +50,7 @@ Single<InteractionsRequest> build(EdgeSetGroupRequest edgeSetRequestGroup) {
 
     return zip(
         this.collectSelectionsAndAggregations(edgeSetRequestGroup),
-        this.buildEntityTypeFilter(edgeSetRequestGroup),
+        this.buildEntityInteractionFilter(edgeSetRequestGroup),
         (selections, filter) ->
             InteractionsRequest.newBuilder()
                 .addAllSelection(selections)
@@ -66,8 +68,8 @@ private Single<Set<Expression>> collectSelectionsAndAggregations(EdgeSetGroupReq
         .collect(Collectors.toUnmodifiableSet());
   }
 
-  private Single<Filter> buildEntityTypeFilter(EdgeSetGroupRequest request) {
-    return Observable.fromIterable(request.entityTypes())
+  private Single<Filter> buildEntityInteractionFilter(EdgeSetGroupRequest request) {
+    return Observable.fromIterable(request.entityTypes()) // add entity types filter
         .collect(Collectors.toUnmodifiableSet())
         .map(
             entityTypes ->
@@ -76,7 +78,13 @@ private Single<Filter> buildEntityTypeFilter(EdgeSetGroupRequest request) {
                     new EntityNeighborTypeFilter(
                         request.neighborTypeAttribute().attributeExpressionAssociation().value(),
                         entityTypes)))
-        .flatMap(filterAssociation -> this.filterConverter.convert(Set.of(filterAssociation)));
+        .flatMap(
+            filterAssociation ->
+                this.filterConverter.convert(
+                    Stream.concat(
+                            request.filterArguments().stream(), // add all other filters
+                            Stream.of(filterAssociation))
+                        .collect(Collectors.toUnmodifiableSet())));
   }
 
   @Value
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/IncomingEdgesDataFetcher.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/IncomingEdgesDataFetcher.java
new file mode 100644
index 00000000..dd506853
--- /dev/null
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/IncomingEdgesDataFetcher.java
@@ -0,0 +1,33 @@
+package org.hypertrace.graphql.entity.dao;
+
+import java.util.List;
+import javax.inject.Inject;
+import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
+import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer;
+import org.hypertrace.graphql.entity.schema.EdgeResultSet;
+import org.hypertrace.graphql.entity.schema.Entity;
+import org.hypertrace.graphql.entity.schema.EntityType;
+
+public class IncomingEdgesDataFetcher extends InjectableDataFetcher<EdgeResultSet> {
+  public IncomingEdgesDataFetcher() {
+    super(IncomingEdgesDataFetcherImpl.class);
+  }
+
+  private static class IncomingEdgesDataFetcherImpl extends EdgesDataFetcherImpl {
+
+    @Inject
+    IncomingEdgesDataFetcherImpl(ArgumentDeserializer argumentDeserializer) {
+      super(argumentDeserializer);
+    }
+
+    @Override
+    protected EdgeResultSet getEdges(
+        Entity entity,
+        EntityType neighborType,
+        String neighborScope,
+        List<FilterArgument> filterBy) {
+      return entity.incomingEdges(neighborType, neighborScope, filterBy);
+    }
+  }
+}
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/OutgoingEdgesDataFetcher.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/OutgoingEdgesDataFetcher.java
new file mode 100644
index 00000000..04541efb
--- /dev/null
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/dao/OutgoingEdgesDataFetcher.java
@@ -0,0 +1,34 @@
+package org.hypertrace.graphql.entity.dao;
+
+import java.util.List;
+import javax.inject.Inject;
+import org.hypertrace.core.graphql.common.fetcher.InjectableDataFetcher;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
+import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer;
+import org.hypertrace.graphql.entity.schema.EdgeResultSet;
+import org.hypertrace.graphql.entity.schema.Entity;
+import org.hypertrace.graphql.entity.schema.EntityType;
+
+public class OutgoingEdgesDataFetcher extends InjectableDataFetcher<EdgeResultSet> {
+
+  public OutgoingEdgesDataFetcher() {
+    super(OutgoingEdgesDataFetcherImpl.class);
+  }
+
+  private static class OutgoingEdgesDataFetcherImpl extends EdgesDataFetcherImpl {
+
+    @Inject
+    OutgoingEdgesDataFetcherImpl(ArgumentDeserializer argumentDeserializer) {
+      super(argumentDeserializer);
+    }
+
+    @Override
+    protected EdgeResultSet getEdges(
+        Entity entity,
+        EntityType neighborType,
+        String neighborScope,
+        List<FilterArgument> filterBy) {
+      return entity.outgoingEdges(neighborType, neighborScope, filterBy);
+    }
+  }
+}
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilder.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilder.java
index 08fde849..0a5a2daf 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilder.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilder.java
@@ -320,6 +320,7 @@ private static class EmptyEdgeSetGroupRequest implements EdgeSetGroupRequest {
     Set<String> entityTypes = Collections.emptySet();
     Collection<AttributeRequest> attributeRequests = Collections.emptyList();
     Collection<MetricAggregationRequest> metricAggregationRequests = Collections.emptyList();
+    Collection<AttributeAssociation<FilterArgument>> filterArguments = Collections.emptyList();
     AttributeRequest neighborIdAttribute = null;
     AttributeRequest neighborTypeAttribute = null;
 
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeRequestBuilder.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeRequestBuilder.java
index 4cad1968..34611e5f 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeRequestBuilder.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeRequestBuilder.java
@@ -3,6 +3,7 @@
 import static io.reactivex.rxjava3.core.Single.zip;
 
 import graphql.schema.SelectedField;
+import io.grpc.Status;
 import io.reactivex.rxjava3.core.Single;
 import java.util.Collection;
 import java.util.List;
@@ -16,11 +17,14 @@
 import javax.inject.Provider;
 import lombok.Value;
 import lombok.experimental.Accessors;
+import org.hypertrace.core.graphql.common.request.AttributeAssociation;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
 import org.hypertrace.core.graphql.common.request.AttributeRequestBuilder;
+import org.hypertrace.core.graphql.common.request.FilterRequestBuilder;
 import org.hypertrace.core.graphql.common.schema.arguments.TimeRangeArgument;
 import org.hypertrace.core.graphql.common.schema.attributes.arguments.AttributeExpression;
 import org.hypertrace.core.graphql.common.schema.results.ResultSet;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.context.GraphQlRequestContext;
 import org.hypertrace.core.graphql.deserialization.ArgumentDeserializer;
 import org.hypertrace.core.graphql.utils.schema.GraphQlSelectionFinder;
@@ -33,6 +37,7 @@
 import org.hypertrace.graphql.metric.request.MetricAggregationRequestBuilder;
 
 class EdgeRequestBuilder {
+
   private final String INCOMING_ENTITY_ID_KEY = "fromEntityId";
   private final String INCOMING_ENTITY_TYPE_KEY = "fromEntityType";
   private final String OUTGOING_ENTITY_ID_KEY = "toEntityId";
@@ -40,6 +45,7 @@ class EdgeRequestBuilder {
   private final ArgumentDeserializer argumentDeserializer;
   private final GraphQlSelectionFinder selectionFinder;
   private final MetricAggregationRequestBuilder metricAggregationRequestBuilder;
+  private final FilterRequestBuilder filterRequestBuilder;
   private final AttributeRequestBuilder attributeRequestBuilder;
   // Use provider to avoid cycle
   private final Provider<NeighborEntitiesRequestBuilder> neighborEntitiesRequestBuilderProvider;
@@ -49,6 +55,7 @@ class EdgeRequestBuilder {
       ArgumentDeserializer argumentDeserializer,
       GraphQlSelectionFinder selectionFinder,
       MetricAggregationRequestBuilder metricAggregationRequestBuilder,
+      FilterRequestBuilder filterRequestBuilder,
       AttributeRequestBuilder attributeRequestBuilder,
       Provider<NeighborEntitiesRequestBuilder> neighborEntitiesRequestBuilderProvider) {
     this.argumentDeserializer = argumentDeserializer;
@@ -56,6 +63,7 @@ class EdgeRequestBuilder {
     this.metricAggregationRequestBuilder = metricAggregationRequestBuilder;
     this.attributeRequestBuilder = attributeRequestBuilder;
     this.neighborEntitiesRequestBuilderProvider = neighborEntitiesRequestBuilderProvider;
+    this.filterRequestBuilder = filterRequestBuilder;
   }
 
   Single<EdgeSetGroupRequest> buildIncomingEdgeRequest(
@@ -63,8 +71,7 @@ Single<EdgeSetGroupRequest> buildIncomingEdgeRequest(
       TimeRangeArgument timeRange,
       Optional<String> space,
       Stream<SelectedField> edgeSetFields) {
-    return this.buildEdgeRequest(
-        context, timeRange, space, this.getEdgesByType(edgeSetFields), EdgeType.INCOMING);
+    return this.buildEdgeRequest(context, timeRange, space, edgeSetFields, EdgeType.INCOMING);
   }
 
   Single<EdgeSetGroupRequest> buildOutgoingEdgeRequest(
@@ -72,17 +79,25 @@ Single<EdgeSetGroupRequest> buildOutgoingEdgeRequest(
       TimeRangeArgument timeRange,
       Optional<String> space,
       Stream<SelectedField> edgeSetFields) {
-    return this.buildEdgeRequest(
-        context, timeRange, space, this.getEdgesByType(edgeSetFields), EdgeType.OUTGOING);
+    return this.buildEdgeRequest(context, timeRange, space, edgeSetFields, EdgeType.OUTGOING);
   }
 
   private Single<EdgeSetGroupRequest> buildEdgeRequest(
       GraphQlRequestContext context,
       TimeRangeArgument timeRange,
       Optional<String> space,
-      Map<String, Set<SelectedField>> edgesByType,
+      Stream<SelectedField> edgeSetFields,
       EdgeType edgeType) {
+    Set<SelectedField> edgeFields = edgeSetFields.collect(Collectors.toUnmodifiableSet());
+    List<FilterArgument> filterArguments = this.getFilters(edgeFields);
+
+    if (!filterArguments.isEmpty() && edgeFields.size() > 1) {
+      throw Status.UNIMPLEMENTED
+          .withDescription("Cannot specify more than one edge type with edge filters")
+          .asRuntimeException();
+    }
 
+    Map<String, Set<SelectedField>> edgesByType = this.getEdgesByType(edgeFields.stream());
     Set<SelectedField> allEdges =
         edgesByType.values().stream()
             .flatMap(Collection::stream)
@@ -94,7 +109,9 @@ private Single<EdgeSetGroupRequest> buildEdgeRequest(
         this.getNeighborTypeAttribute(context, edgeType),
         this.metricAggregationRequestBuilder.build(
             context, HypertraceAttributeScopeString.INTERACTION, allEdges.stream()),
-        (attributeRequests, neighborIdRequest, neighborTypeRequest, metricRequests) ->
+        this.filterRequestBuilder.build(
+            context, HypertraceAttributeScopeString.INTERACTION, filterArguments),
+        (attributeRequests, neighborIdRequest, neighborTypeRequest, metricRequests, filters) ->
             new DefaultEdgeSetGroupRequest(
                 edgesByType.keySet(),
                 attributeRequests,
@@ -110,7 +127,8 @@ private Single<EdgeSetGroupRequest> buildEdgeRequest(
                             timeRange,
                             space,
                             neighborIds,
-                            edgesByType.get(entityType))));
+                            edgesByType.get(entityType)),
+                filters));
   }
 
   private Map<String, Set<SelectedField>> getEdgesByType(Stream<SelectedField> edgeSetStream) {
@@ -165,6 +183,17 @@ private Single<AttributeRequest> getNeighborIdAttribute(
     }
   }
 
+  private List<FilterArgument> getFilters(Set<SelectedField> selectedFields) {
+    return selectedFields.stream()
+        .map(
+            selectedField ->
+                this.argumentDeserializer.deserializeObjectList(
+                    selectedField.getArguments(), FilterArgument.class))
+        .flatMap(Optional::stream)
+        .flatMap(Collection::stream)
+        .collect(Collectors.toUnmodifiableList());
+  }
+
   private Single<AttributeRequest> getNeighborTypeAttribute(
       GraphQlRequestContext context, EdgeType edgeType) {
     switch (edgeType) {
@@ -191,12 +220,14 @@ private enum EdgeType {
   @Value
   @Accessors(fluent = true)
   private static class DefaultEdgeSetGroupRequest implements EdgeSetGroupRequest {
+
     Set<String> entityTypes;
     Collection<AttributeRequest> attributeRequests;
     Collection<MetricAggregationRequest> metricAggregationRequests;
     AttributeRequest neighborIdAttribute;
     AttributeRequest neighborTypeAttribute;
     BiFunction<String, Collection<String>, Single<EntityRequest>> neighborRequestBuilder;
+    Collection<AttributeAssociation<FilterArgument>> filterArguments;
 
     @Override
     public Single<EntityRequest> buildNeighborRequest(
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeSetGroupRequest.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeSetGroupRequest.java
index fc7d6bef..c6859008 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeSetGroupRequest.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/request/EdgeSetGroupRequest.java
@@ -3,7 +3,9 @@
 import io.reactivex.rxjava3.core.Single;
 import java.util.Collection;
 import java.util.Set;
+import org.hypertrace.core.graphql.common.request.AttributeAssociation;
 import org.hypertrace.core.graphql.common.request.AttributeRequest;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.graphql.metric.request.MetricAggregationRequest;
 
 public interface EdgeSetGroupRequest {
@@ -20,4 +22,6 @@ public interface EdgeSetGroupRequest {
   AttributeRequest neighborTypeAttribute();
 
   Single<EntityRequest> buildNeighborRequest(String entityType, Collection<String> neighborIds);
+
+  Collection<AttributeAssociation<FilterArgument>> filterArguments();
 }
diff --git a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/schema/Entity.java b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/schema/Entity.java
index cc381887..8d9c8696 100644
--- a/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/schema/Entity.java
+++ b/hypertrace-graphql-entity-schema/src/main/java/org/hypertrace/graphql/entity/schema/Entity.java
@@ -1,11 +1,16 @@
 package org.hypertrace.graphql.entity.schema;
 
+import graphql.annotations.annotationTypes.GraphQLDataFetcher;
 import graphql.annotations.annotationTypes.GraphQLField;
 import graphql.annotations.annotationTypes.GraphQLName;
 import graphql.annotations.annotationTypes.GraphQLNonNull;
+import java.util.List;
 import org.hypertrace.core.graphql.common.schema.attributes.AttributeQueryable;
 import org.hypertrace.core.graphql.common.schema.id.Identifiable;
+import org.hypertrace.core.graphql.common.schema.results.arguments.filter.FilterArgument;
 import org.hypertrace.core.graphql.common.schema.type.Typed;
+import org.hypertrace.graphql.entity.dao.IncomingEdgesDataFetcher;
+import org.hypertrace.graphql.entity.dao.OutgoingEdgesDataFetcher;
 import org.hypertrace.graphql.entity.schema.argument.NeighborEntityScopeArgument;
 import org.hypertrace.graphql.entity.schema.argument.NeighborEntityTypeArgument;
 import org.hypertrace.graphql.label.schema.LabelResultSet;
@@ -27,16 +32,20 @@ public interface Entity extends AttributeQueryable, MetricQueryable, Identifiabl
   @GraphQLField
   @GraphQLNonNull
   @GraphQLName(ENTITY_INCOMING_EDGES_KEY)
+  @GraphQLDataFetcher(IncomingEdgesDataFetcher.class)
   EdgeResultSet incomingEdges(
       @GraphQLName(NeighborEntityTypeArgument.ARGUMENT_NAME) EntityType neighborType,
-      @GraphQLName(NeighborEntityScopeArgument.ARGUMENT_NAME) String neighborScope);
+      @GraphQLName(NeighborEntityScopeArgument.ARGUMENT_NAME) String neighborScope,
+      @GraphQLName(FilterArgument.ARGUMENT_NAME) List<FilterArgument> filterBy);
 
   @GraphQLField
   @GraphQLNonNull
   @GraphQLName(ENTITY_OUTGOING_EDGES_KEY)
+  @GraphQLDataFetcher(OutgoingEdgesDataFetcher.class)
   EdgeResultSet outgoingEdges(
       @GraphQLName(NeighborEntityTypeArgument.ARGUMENT_NAME) EntityType neighborType,
-      @GraphQLName(NeighborEntityScopeArgument.ARGUMENT_NAME) String neighborScope);
+      @GraphQLName(NeighborEntityScopeArgument.ARGUMENT_NAME) String neighborScope,
+      @GraphQLName(FilterArgument.ARGUMENT_NAME) List<FilterArgument> filterBy);
 
   @GraphQLField
   @GraphQLNonNull
diff --git a/hypertrace-graphql-entity-schema/src/test/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilderTest.java b/hypertrace-graphql-entity-schema/src/test/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilderTest.java
index 9c359a7b..e5dcadeb 100644
--- a/hypertrace-graphql-entity-schema/src/test/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilderTest.java
+++ b/hypertrace-graphql-entity-schema/src/test/java/org/hypertrace/graphql/entity/joiner/DefaultEntityJoinerBuilderTest.java
@@ -342,12 +342,14 @@ public Object attribute(AttributeExpression attributeExpression) {
     }
 
     @Override
-    public EdgeResultSet incomingEdges(EntityType neighborType, String neighborScope) {
+    public EdgeResultSet incomingEdges(
+        EntityType neighborType, String neighborScope, List<FilterArgument> filterBy) {
       return null;
     }
 
     @Override
-    public EdgeResultSet outgoingEdges(EntityType neighborType, String neighborScope) {
+    public EdgeResultSet outgoingEdges(
+        EntityType neighborType, String neighborScope, List<FilterArgument> filterBy) {
       return null;
     }
 
diff --git a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java
index b2fbdddd..a15737a6 100644
--- a/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java
+++ b/hypertrace-graphql-labels-schema-impl/src/main/java/org/hypertrace/graphql/label/joiner/DefaultEntityAndRuleJoinerBuilder.java
@@ -319,6 +319,7 @@ private static class EmptyEdgeSetGroupRequest implements EdgeSetGroupRequest {
     Set<String> entityTypes = Collections.emptySet();
     Collection<AttributeRequest> attributeRequests = Collections.emptyList();
     Collection<MetricAggregationRequest> metricAggregationRequests = Collections.emptyList();
+    Collection<AttributeAssociation<FilterArgument>> filterArguments = Collections.emptyList();
     AttributeRequest neighborIdAttribute = null;
     AttributeRequest neighborTypeAttribute = null;