diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3fcd41e600707..50fb1421449b3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ## [Unreleased 3.x]
 ### Added
 - Use Lucene `pack` method for `half_float` and `usigned_long` when using `ApproximatePointRangeQuery`.
+- Add a mapper for context aware segments grouping criteria ([#19233](https://github.com/opensearch-project/OpenSearch/pull/19233))
 
 ### Changed
 - Refactor to move prepareIndex and prepareDelete methods to Engine class ([#19551](https://github.com/opensearch-project/OpenSearch/pull/19551))
diff --git a/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java b/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
index ea34763c487a1..af858b57471e3 100644
--- a/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
+++ b/modules/lang-painless/src/main/java/org/opensearch/painless/PainlessModulePlugin.java
@@ -59,6 +59,7 @@
 import org.opensearch.repositories.RepositoriesService;
 import org.opensearch.rest.RestController;
 import org.opensearch.rest.RestHandler;
+import org.opensearch.script.ContextAwareGroupingScript;
 import org.opensearch.script.DerivedFieldScript;
 import org.opensearch.script.IngestScript;
 import org.opensearch.script.ScoreScript;
@@ -120,6 +121,9 @@ public final class PainlessModulePlugin extends Plugin implements ScriptPlugin,
         derived.add(AllowlistLoader.loadFromResourceFiles(Allowlist.class, "org.opensearch.derived.txt"));
         map.put(DerivedFieldScript.CONTEXT, derived);
 
+        // Only basic painless support for ContextAwareGrouping script
+        map.put(ContextAwareGroupingScript.CONTEXT, new ArrayList<>(Allowlist.BASE_ALLOWLISTS));
+
         allowlists = map;
     }
 
diff --git a/modules/lang-painless/src/test/java/org/opensearch/painless/ContextAwareGroupingScriptTests.java b/modules/lang-painless/src/test/java/org/opensearch/painless/ContextAwareGroupingScriptTests.java
new file mode 100644
index 0000000000000..3c27eb7d9b730
--- /dev/null
+++ b/modules/lang-painless/src/test/java/org/opensearch/painless/ContextAwareGroupingScriptTests.java
@@ -0,0 +1,67 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.painless;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.painless.spi.Allowlist;
+import org.opensearch.script.ContextAwareGroupingScript;
+import org.opensearch.script.ScriptContext;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+public class ContextAwareGroupingScriptTests extends ScriptTestCase {
+
+    private static PainlessScriptEngine SCRIPT_ENGINE;
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        Map<ScriptContext<?>, List<Allowlist>> contexts = newDefaultContexts();
+        List<Allowlist> allowlists = new ArrayList<>(Allowlist.BASE_ALLOWLISTS);
+        contexts.put(ContextAwareGroupingScript.CONTEXT, allowlists);
+
+        SCRIPT_ENGINE = new PainlessScriptEngine(Settings.EMPTY, contexts);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        super.tearDown();
+        SCRIPT_ENGINE = null;
+    }
+
+    @Override
+    protected PainlessScriptEngine getEngine() {
+        return SCRIPT_ENGINE;
+    }
+
+    public void testContextAwareGroupingScript() {
+        String stringConcat = "ctx.value + \"-context-aware\"";
+        ContextAwareGroupingScript script = compile(stringConcat);
+
+        assertEquals("value-context-aware", script.execute(Map.of("value", "value")));
+
+        String integerAddition = "String.valueOf(ctx.value / 100)";
+        ContextAwareGroupingScript integerAdditionScript = compile(integerAddition);
+        assertEquals("2", integerAdditionScript.execute(Map.of("value", 200)));
+    }
+
+    private ContextAwareGroupingScript compile(String expression) {
+        ContextAwareGroupingScript.Factory factory = getEngine().compile(
+            expression,
+            expression,
+            ContextAwareGroupingScript.CONTEXT,
+            Collections.emptyMap()
+        );
+        return factory.newInstance();
+    }
+}
diff --git a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/71_context_api.yml b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/71_context_api.yml
index 20e6fd351a4b9..10fa6fa62ca14 100644
--- a/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/71_context_api.yml
+++ b/modules/lang-painless/src/yamlRestTest/resources/rest-api-spec/test/painless/71_context_api.yml
@@ -2,7 +2,7 @@
     - do:
         scripts_painless_context: {}
     - match: { contexts.0: aggregation_selector}
-    - match: { contexts.24: update}
+    - match: { contexts.25: update}
 ---
 
 "Action to get all API values for score context":
diff --git a/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java b/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java
index 7239ddfb26c0d..1c8254d96682c 100644
--- a/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java
+++ b/server/src/main/java/org/opensearch/index/mapper/CompositeMappedFieldType.java
@@ -50,7 +50,8 @@ public CompositeMappedFieldType(String name, List<String> fields, CompositeField
      */
     @ExperimentalApi
     public enum CompositeFieldType {
-        STAR_TREE("star_tree");
+        STAR_TREE("star_tree"),
+        CONTEXT_AWARE_GROUPING("context_aware_grouping");
 
         private final String name;
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapper.java
new file mode 100644
index 0000000000000..37267371f8bf7
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapper.java
@@ -0,0 +1,184 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.script.ContextAwareGroupingScript;
+import org.opensearch.script.Script;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.opensearch.script.Script.DEFAULT_SCRIPT_LANG;
+
+/**
+ * A field mapper to specify context aware grouping mapper creation
+ *
+ * @opensearch.internal
+ */
+public class ContextAwareGroupingFieldMapper extends ParametrizedFieldMapper {
+
+    public static final String CONTENT_TYPE = "context_aware_grouping";
+
+    public static final Mapper.TypeParser PARSER = new TypeParser();
+
+    private static class TypeParser implements Mapper.TypeParser {
+
+        @Override
+        public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext context) throws MapperParsingException {
+            throw new IllegalStateException("ContextAwareGroupingFieldMapper needs objbuilder to validate node");
+        }
+
+        @Override
+        public Mapper.Builder<?> parse(String name, Map<String, Object> node, ParserContext context, ObjectMapper.Builder objBuilder)
+            throws MapperParsingException {
+            Builder builder = new Builder(name);
+            builder.parse(name, context, node);
+
+            if (builder.fields.isConfigured() == false) {
+                throw new MapperParsingException("[fields] in context_aware_grouping is required");
+            }
+
+            Set<String> propertyFieldNames = (Set<String>) objBuilder.mappersBuilders.stream()
+                .map(b -> ((Mapper.Builder) b).name())
+                .collect(Collectors.toSet());
+
+            if (propertyFieldNames.containsAll(builder.fields.getValue()) == false) {
+                throw new MapperParsingException(
+                    "[fields] should be from properties: [" + propertyFieldNames + "] but found [" + builder.fields.getValue() + "]"
+                );
+            }
+
+            final Script s = builder.script.getValue();
+            if (s != null) {
+                ContextAwareGroupingScript.Factory factory = context.scriptService()
+                    .compile(builder.script.get(), ContextAwareGroupingScript.CONTEXT);
+                builder.compiledScript = factory.newInstance();
+            }
+            return builder;
+        }
+    }
+
+    /**
+     * Builder for this field mapper
+     *
+     * @opensearch.internal
+     */
+    public static class Builder extends ParametrizedFieldMapper.Builder {
+
+        private static ContextAwareGroupingFieldMapper toType(FieldMapper in) {
+            return (ContextAwareGroupingFieldMapper) in;
+        }
+
+        private final Parameter<List<String>> fields = new Parameter<>("fields", true, Collections::emptyList, (n, c, o) -> {
+            if (!(o instanceof List)) {
+                throw new MapperParsingException("Expected [fields] to be a list of strings but got [" + o + "]");
+            }
+
+            List<String> fields = (List<String>) o;
+            if (fields.isEmpty()) {
+                throw new MapperParsingException("Expected [fields] in context_aware_grouping to have one value");
+            }
+
+            if (fields.size() > 1) {
+                throw new MapperParsingException("Currently [fields] in context_aware_grouping does not support multiple values");
+            }
+
+            return fields;
+        }, m -> toType(m).fields);
+
+        private final Parameter<Script> script = new Parameter<>("script", true, () -> null, (n, c, o) -> {
+            if (o == null) {
+                return null;
+            }
+
+            Script s = Script.parse(o);
+            if (!s.getLang().equals(DEFAULT_SCRIPT_LANG)) {
+                throw new MapperParsingException("context_aware_grouping only supports painless script");
+            }
+            return s;
+        }, m -> toType(m).script).acceptsNull();
+
+        private ContextAwareGroupingScript compiledScript;
+
+        /**
+         * Creates a new Builder with a field name
+         *
+         * @param name
+         */
+        protected Builder(String name) {
+            super(name);
+        }
+
+        protected Builder(String name, List<String> fields, Script script, ContextAwareGroupingScript contextAwareGroupingScript) {
+            super(name);
+            this.fields.setValue(fields);
+            this.script.setValue(script);
+            this.compiledScript = contextAwareGroupingScript;
+        }
+
+        @Override
+        protected List<Parameter<?>> getParameters() {
+            return List.of(fields, script);
+        }
+
+        @Override
+        public ParametrizedFieldMapper build(BuilderContext context) {
+            final ContextAwareGroupingFieldType contextAwareGroupingFieldType = new ContextAwareGroupingFieldType(
+                this.fields.getValue(),
+                this.compiledScript
+            );
+            return new ContextAwareGroupingFieldMapper(name, contextAwareGroupingFieldType, this);
+        }
+    }
+
+    private final List<String> fields;
+    private final Script script;
+    private final ContextAwareGroupingScript compiledScript;
+
+    /**
+     * Creates a new ParametrizedFieldMapper
+     *
+     * @param simpleName
+     * @param mappedFieldType
+     * @param builder
+     */
+    protected ContextAwareGroupingFieldMapper(
+        String simpleName,
+        ContextAwareGroupingFieldType mappedFieldType,
+        ContextAwareGroupingFieldMapper.Builder builder
+    ) {
+        super(simpleName, mappedFieldType, MultiFields.empty(), CopyTo.empty());
+        this.fields = builder.fields.getValue();
+        this.script = builder.script.getValue();
+        this.compiledScript = builder.compiledScript;
+    }
+
+    @Override
+    public Builder getMergeBuilder() {
+        return new Builder(CONTENT_TYPE, this.fields, this.script, this.compiledScript);
+    }
+
+    @Override
+    protected void parseCreateField(ParseContext context) throws IOException {
+        throw new MapperParsingException("context_aware_grouping cannot be ingested in the document");
+    }
+
+    public ContextAwareGroupingFieldType fieldType() {
+        return (ContextAwareGroupingFieldType) mappedFieldType;
+    }
+
+    @Override
+    protected String contentType() {
+        return CONTENT_TYPE;
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldType.java b/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldType.java
new file mode 100644
index 0000000000000..2ddbb81c8de3a
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/ContextAwareGroupingFieldType.java
@@ -0,0 +1,60 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.search.Query;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.ContextAwareGroupingScript;
+import org.opensearch.search.lookup.SearchLookup;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Field type for context_aware_grouping field mapper
+ *
+ * @opensearch.internal
+ */
+public class ContextAwareGroupingFieldType extends CompositeMappedFieldType {
+
+    private ContextAwareGroupingScript compiledScript;
+
+    public ContextAwareGroupingFieldType(final List<String> fields, final ContextAwareGroupingScript compiledScript) {
+        super(
+            ContextAwareGroupingFieldMapper.CONTENT_TYPE,
+            false,
+            false,
+            false,
+            TextSearchInfo.NONE,
+            Collections.emptyMap(),
+            fields,
+            CompositeFieldType.CONTEXT_AWARE_GROUPING
+        );
+        this.compiledScript = compiledScript;
+    }
+
+    public ContextAwareGroupingScript compiledScript() {
+        return compiledScript;
+    }
+
+    @Override
+    public ValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+        throw new UnsupportedOperationException("valueFetcher is not supported for context_aware_grouping field");
+    }
+
+    @Override
+    public String typeName() {
+        return ContextAwareGroupingFieldMapper.CONTENT_TYPE;
+    }
+
+    @Override
+    public Query termQuery(Object value, QueryShardContext context) {
+        throw new UnsupportedOperationException("Term query is not supported for context_aware_grouping field");
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
index 51400567025eb..d7b199fb1702c 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DateFieldMapper.java
@@ -814,18 +814,7 @@ protected DateFieldMapper clone() {
 
     @Override
     protected void parseCreateField(ParseContext context) throws IOException {
-        String dateAsString;
-        if (context.externalValueSet()) {
-            Object dateAsObject = context.externalValue();
-            if (dateAsObject == null) {
-                dateAsString = null;
-            } else {
-                dateAsString = dateAsObject.toString();
-            }
-        } else {
-            dateAsString = context.parser().textOrNull();
-        }
-
+        String dateAsString = getFieldValue(context);
         long timestamp;
         if (dateAsString == null) {
             if (nullValue == null) {
@@ -875,6 +864,20 @@ boolean isSkiplistDefaultEnabled(IndexSortConfig indexSortConfig, String fieldNa
         return false;
     }
 
+    @Override
+    protected String getFieldValue(ParseContext context) throws IOException {
+        if (context.externalValueSet()) {
+            Object dateAsObject = context.externalValue();
+            if (dateAsObject == null) {
+                return null;
+            } else {
+                return dateAsObject.toString();
+            }
+        } else {
+            return context.parser().textOrNull();
+        }
+    }
+
     public Long getNullValue() {
         return nullValue;
     }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java b/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
index 213fb48595b8b..f5fc4789d1868 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DocumentParser.java
@@ -47,6 +47,7 @@
 import org.opensearch.core.xcontent.XContentParser;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.DynamicTemplate.XContentFieldType;
+import org.opensearch.script.ContextAwareGroupingScript;
 
 import java.io.IOException;
 import java.time.format.DateTimeParseException;
@@ -55,6 +56,8 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 import static org.opensearch.index.mapper.FieldMapper.IGNORE_MALFORMED_SETTING;
 
@@ -417,6 +420,7 @@ static void parseObjectOrNested(ParseContext context, ObjectMapper mapper) throw
         }
 
         innerParseObject(context, mapper, parser, currentFieldName, token);
+
         // restore the enable path flag
         if (nested.isNested()) {
             nested(context, nested);
@@ -462,11 +466,34 @@ private static void innerParseObject(
                 }
                 token = parser.nextToken();
             }
+            generateGroupingCriteria(context);
         } finally {
             context.decrementFieldCurrentDepth();
         }
     }
 
+    private static void generateGroupingCriteria(ParseContext context) {
+        if (context.docMapper() != null && context.docMapper().mappers() != null) {
+            final Mapper mapper = context.docMapper().mappers().getMapper(ContextAwareGroupingFieldMapper.CONTENT_TYPE);
+            if (mapper != null) {
+                final ContextAwareGroupingFieldMapper groupingFieldMapper = (ContextAwareGroupingFieldMapper) mapper;
+                final ContextAwareGroupingScript script = groupingFieldMapper.fieldType().compiledScript();
+                ParseContext.Document doc = context.doc();
+                if (script != null) {
+                    doc.setGroupingCriteria(script.execute(doc.getGroupingCriteriaParams()));
+                } else {
+                    Map<String, Object> groupingCriteriaParams = doc.getGroupingCriteriaParams();
+                    String criteria = groupingFieldMapper.fieldType()
+                        .fields()
+                        .stream()
+                        .map(field -> groupingCriteriaParams.get(field).toString())
+                        .collect(Collectors.joining("-"));
+                    doc.setGroupingCriteria(criteria);
+                }
+            }
+        }
+    }
+
     private static void nested(ParseContext context, ObjectMapper.Nested nested) {
         ParseContext.Document nestedDoc = context.doc();
         ParseContext.Document parentDoc = nestedDoc.getParent();
diff --git a/server/src/main/java/org/opensearch/index/mapper/FieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/FieldMapper.java
index aaa2c9c029974..cdab7cf4766a5 100644
--- a/server/src/main/java/org/opensearch/index/mapper/FieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/FieldMapper.java
@@ -284,6 +284,7 @@ private boolean shouldIgnoreMalformed(IndexSettings is) {
     public void parse(ParseContext context) throws IOException {
         try {
             parseCreateField(context);
+            extractGroupingCriteriaParams(context);
         } catch (Exception e) {
 
             boolean ignoreMalformed = shouldIgnoreMalformed(context.indexSettings());
@@ -331,6 +332,35 @@ public void parse(ParseContext context) throws IOException {
      */
     protected abstract void parseCreateField(ParseContext context) throws IOException;
 
+    private void extractGroupingCriteriaParams(ParseContext context) throws IOException {
+        if (context.docMapper() != null && context.docMapper().mappers() != null) {
+            final Mapper mapper = context.docMapper().mappers().getMapper(ContextAwareGroupingFieldMapper.CONTENT_TYPE);
+            if (mapper != null) {
+                final ContextAwareGroupingFieldMapper contextAwareMapper = (ContextAwareGroupingFieldMapper) mapper;
+                if (contextAwareMapper.fieldType().fields().contains(name())) {
+                    Object value = getFieldValue(context);
+                    if (value == null) {
+                        throw new IllegalArgumentException(
+                            "field ["
+                                + name()
+                                + "] of type ["
+                                + fieldType().typeName()
+                                + "] cannot be null"
+                                + " when context-aware-grouping is set on that field"
+                        );
+                    }
+                    context.doc().addGroupingCriteriaParams(name(), value);
+                }
+            }
+        }
+    }
+
+    protected Object getFieldValue(ParseContext context) throws IOException {
+        throw new UnsupportedOperationException(
+            "getFieldValue not implemented for the field mapper [" + this.getClass().getSimpleName() + "]"
+        );
+    }
+
     protected final void createFieldNamesField(ParseContext context) {
         assert fieldType().hasDocValues() == false : "_field_names should only be used when doc_values are turned off";
         FieldNamesFieldType fieldNamesFieldType = context.docMapper().metadataMapper(FieldNamesFieldMapper.class).fieldType();
diff --git a/server/src/main/java/org/opensearch/index/mapper/IpFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/IpFieldMapper.java
index b2e8f75a4f444..992007329a135 100644
--- a/server/src/main/java/org/opensearch/index/mapper/IpFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/IpFieldMapper.java
@@ -633,6 +633,28 @@ protected IpFieldMapper clone() {
 
     @Override
     protected void parseCreateField(ParseContext context) throws IOException {
+        final InetAddress address = getFieldValue(context);
+        if (address == null) {
+            return;
+        }
+
+        if (indexed && hasDocValues) {
+            context.doc().add(new InetAddressField(fieldType().name(), address));
+        } else if (indexed) {
+            context.doc().add(new InetAddressPoint(fieldType().name(), address));
+        } else if (hasDocValues) {
+            context.doc().add(new SortedSetDocValuesField(fieldType().name(), new BytesRef(InetAddressPoint.encode(address))));
+        }
+        if ((stored || indexed) && hasDocValues == false) {
+            createFieldNamesField(context);
+        }
+        if (stored) {
+            context.doc().add(new StoredField(fieldType().name(), new BytesRef(InetAddressPoint.encode(address))));
+        }
+    }
+
+    @Override
+    protected InetAddress getFieldValue(ParseContext context) throws IOException {
         Object addressAsObject;
         if (context.externalValueSet()) {
             addressAsObject = context.externalValue();
@@ -645,39 +667,24 @@ protected void parseCreateField(ParseContext context) throws IOException {
         }
 
         if (addressAsObject == null) {
-            return;
+            return null;
         }
 
-        String addressAsString = addressAsObject.toString();
-        InetAddress address;
         if (addressAsObject instanceof InetAddress) {
-            address = (InetAddress) addressAsObject;
+            return (InetAddress) addressAsObject;
         } else {
             try {
-                address = InetAddresses.forString(addressAsString);
+                String addressAsString = addressAsObject.toString();
+                return InetAddresses.forString(addressAsString);
             } catch (IllegalArgumentException e) {
                 if (ignoreMalformed().value()) {
                     context.addIgnoredField(fieldType().name());
-                    return;
+                    return null;
                 } else {
                     throw e;
                 }
             }
         }
-
-        if (indexed && hasDocValues) {
-            context.doc().add(new InetAddressField(fieldType().name(), address));
-        } else if (indexed) {
-            context.doc().add(new InetAddressPoint(fieldType().name(), address));
-        } else if (hasDocValues) {
-            context.doc().add(new SortedSetDocValuesField(fieldType().name(), new BytesRef(InetAddressPoint.encode(address))));
-        }
-        if ((stored || indexed) && hasDocValues == false) {
-            createFieldNamesField(context);
-        }
-        if (stored) {
-            context.doc().add(new StoredField(fieldType().name(), new BytesRef(InetAddressPoint.encode(address))));
-        }
     }
 
     public static InetAddressField buildInetAddressField(String name, InetAddress value) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
index fa9f4b4450a2c..6bb38f4690cc3 100644
--- a/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/NumberFieldMapper.java
@@ -2136,46 +2136,46 @@ protected NumberFieldMapper clone() {
 
     @Override
     protected void parseCreateField(ParseContext context) throws IOException {
+        Number numericValue = getFieldValue(context);
+        if (numericValue == null) {
+            return;
+        }
+
+        context.doc().addAll(fieldType().type.createFields(fieldType().name(), numericValue, indexed, hasDocValues, skiplist, stored));
+
+        if (hasDocValues == false && (stored || indexed)) {
+            createFieldNamesField(context);
+        }
+    }
+
+    @Override
+    protected Number getFieldValue(ParseContext context) throws IOException {
         XContentParser parser = context.parser();
-        Object value;
-        Number numericValue = null;
+        Number value;
         if (context.externalValueSet()) {
-            value = context.externalValue();
+            return fieldType().type.parse(context.externalValue(), coerce.value());
         } else if (parser.currentToken() == Token.VALUE_NULL) {
-            value = null;
+            value = nullValue;
         } else if (coerce.value() && parser.currentToken() == Token.VALUE_STRING && parser.textLength() == 0) {
-            value = null;
+            value = nullValue;
         } else {
             try {
-                numericValue = fieldType().type.parse(parser, coerce.value());
+                value = fieldType().type.parse(parser, coerce.value());
             } catch (InputCoercionException | IllegalArgumentException | JsonParseException e) {
                 if (ignoreMalformed.value() && parser.currentToken().isValue()) {
                     context.addIgnoredField(mappedFieldType.name());
-                    return;
+                    return null;
                 } else {
                     throw e;
                 }
             }
-            value = numericValue;
         }
 
         if (value == null) {
-            value = nullValue;
-        }
-
-        if (value == null) {
-            return;
-        }
-
-        if (numericValue == null) {
-            numericValue = fieldType().type.parse(value, coerce.value());
+            return nullValue;
         }
 
-        context.doc().addAll(fieldType().type.createFields(fieldType().name(), numericValue, indexed, hasDocValues, skiplist, stored));
-
-        if (hasDocValues == false && (stored || indexed)) {
-            createFieldNamesField(context);
-        }
+        return value;
     }
 
     @Override
diff --git a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
index 42373d5686543..1ba2a49c035ee 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ObjectMapper.java
@@ -868,7 +868,7 @@ public int compare(Mapper o1, Mapper o2) {
 
         Mapper[] sortedMappers = mappers.values()
             .stream()
-            .filter(m -> !(m instanceof DerivedFieldMapper))
+            .filter(m -> !(m instanceof DerivedFieldMapper || m instanceof ContextAwareGroupingFieldMapper))
             .toArray(size -> new Mapper[size]);
         Arrays.sort(sortedMappers, new Comparator<Mapper>() {
             @Override
@@ -897,9 +897,15 @@ public int compare(Mapper o1, Mapper o2) {
                 mapper.toXContent(builder, params);
             }
         }
+
         if (count > 0) {
             builder.endObject();
         }
+
+        final Mapper contextAwareGroupingMapper = mappers.get(ContextAwareGroupingFieldMapper.CONTENT_TYPE);
+        if (contextAwareGroupingMapper != null) {
+            contextAwareGroupingMapper.toXContent(builder, params);
+        }
         builder.endObject();
     }
 
diff --git a/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
index 927e5ba90fe64..db2b3c0deea88 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ParametrizedFieldMapper.java
@@ -679,7 +679,7 @@ public final void parse(String name, ParserContext parserContext, Map<String, Ob
                 Map.Entry<String, Object> entry = iterator.next();
                 final String propName = entry.getKey();
                 final Object propNode = entry.getValue();
-                if (Objects.equals("fields", propName)) {
+                if (Objects.equals("fields", propName) && !name.equals(ContextAwareGroupingFieldMapper.CONTENT_TYPE)) {
                     TypeParsers.parseMultiField(multiFieldsBuilder::add, name, parserContext, propName, propNode);
                     iterator.remove();
                     continue;
diff --git a/server/src/main/java/org/opensearch/index/mapper/ParseContext.java b/server/src/main/java/org/opensearch/index/mapper/ParseContext.java
index 5d382ff28bcf9..539fa0468820e 100644
--- a/server/src/main/java/org/opensearch/index/mapper/ParseContext.java
+++ b/server/src/main/java/org/opensearch/index/mapper/ParseContext.java
@@ -72,6 +72,8 @@ public static class Document implements Iterable<IndexableField> {
         private final String prefix;
         private final List<IndexableField> fields;
         private Map<Object, IndexableField> keyedFields;
+        private Map<String, Object> groupingCriteriaParams;
+        private String groupingCriteria;
 
         private Document(String path, Document parent) {
             fields = new ArrayList<>();
@@ -114,6 +116,25 @@ public List<IndexableField> getFields() {
             return fields;
         }
 
+        public void addGroupingCriteriaParams(final String fieldName, final Object value) {
+            if (groupingCriteriaParams != null) {
+                throw new IllegalArgumentException("grouping criteria params already set");
+            }
+            groupingCriteriaParams = Map.of(fieldName, value);
+        }
+
+        public Map<String, Object> getGroupingCriteriaParams() {
+            return groupingCriteriaParams;
+        }
+
+        public void setGroupingCriteria(String groupingCriteria) {
+            this.groupingCriteria = groupingCriteria;
+        }
+
+        public String getGroupingCriteria() {
+            return groupingCriteria;
+        }
+
         public void addAll(List<? extends IndexableField> fields) {
             this.fields.addAll(fields);
         }
diff --git a/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java b/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
index 8aa0762364371..11f8d38249c56 100644
--- a/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/RootObjectMapper.java
@@ -182,6 +182,7 @@ public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext
             RootObjectMapper.Builder builder = new Builder(name);
             Iterator<Map.Entry<String, Object>> iterator = node.entrySet().iterator();
             Object compositeField = null;
+            Object contextAwareGoupingField = null;
             while (iterator.hasNext()) {
                 Map.Entry<String, Object> entry = iterator.next();
                 String fieldName = entry.getKey();
@@ -189,6 +190,9 @@ public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext
                 if (fieldName.equals("composite")) {
                     compositeField = fieldNode;
                     iterator.remove();
+                } else if (fieldName.equals(ContextAwareGroupingFieldMapper.CONTENT_TYPE)) {
+                    contextAwareGoupingField = fieldNode;
+                    iterator.remove();
                 } else {
                     if (parseObjectOrDocumentTypeProperties(fieldName, fieldNode, parserContext, builder)
                         || processField(builder, fieldName, fieldNode, parserContext)) {
@@ -201,9 +205,28 @@ public Mapper.Builder parse(String name, Map<String, Object> node, ParserContext
             if (compositeField != null) {
                 parseCompositeField(builder, (Map<String, Object>) compositeField, parserContext);
             }
+
+            if (contextAwareGoupingField != null) {
+                parseContextAwareGroupingField(builder, (Map<String, Object>) contextAwareGoupingField, parserContext);
+            }
             return builder;
         }
 
+        protected static void parseContextAwareGroupingField(
+            ObjectMapper.Builder objBuilder,
+            Map<String, Object> contextAwareGroupingNode,
+            ParserContext parserContext
+        ) {
+            Mapper.TypeParser typeParser = parserContext.typeParser(ContextAwareGroupingFieldMapper.CONTENT_TYPE);
+            Mapper.Builder<?> mapperBuilder = typeParser.parse(
+                ContextAwareGroupingFieldMapper.CONTENT_TYPE,
+                contextAwareGroupingNode,
+                parserContext,
+                objBuilder
+            );
+            objBuilder.add(mapperBuilder);
+        }
+
         protected boolean processField(RootObjectMapper.Builder builder, String fieldName, Object fieldNode, ParserContext parserContext) {
             if (fieldName.equals("date_formats") || fieldName.equals("dynamic_date_formats")) {
                 if (fieldNode instanceof List) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
index bb726893b3d17..50b30e65e315a 100644
--- a/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/TextFieldMapper.java
@@ -1035,13 +1035,7 @@ public ParametrizedFieldMapper.Builder getMergeBuilder() {
 
     @Override
     protected void parseCreateField(ParseContext context) throws IOException {
-        final String value;
-        if (context.externalValueSet()) {
-            value = context.externalValue().toString();
-        } else {
-            value = context.parser().textOrNull();
-        }
-
+        final String value = getFieldValue(context);
         if (value == null) {
             return;
         }
@@ -1061,6 +1055,15 @@ protected void parseCreateField(ParseContext context) throws IOException {
         }
     }
 
+    @Override
+    protected String getFieldValue(ParseContext context) throws IOException {
+        if (context.externalValueSet()) {
+            return context.externalValue().toString();
+        } else {
+            return context.parser().textOrNull();
+        }
+    }
+
     @Override
     public Iterator<Mapper> iterator() {
         List<Mapper> subIterators = new ArrayList<>();
diff --git a/server/src/main/java/org/opensearch/indices/IndicesModule.java b/server/src/main/java/org/opensearch/indices/IndicesModule.java
index 2cd06493e8277..2192872c6c752 100644
--- a/server/src/main/java/org/opensearch/indices/IndicesModule.java
+++ b/server/src/main/java/org/opensearch/indices/IndicesModule.java
@@ -47,6 +47,7 @@
 import org.opensearch.index.mapper.BooleanFieldMapper;
 import org.opensearch.index.mapper.CompletionFieldMapper;
 import org.opensearch.index.mapper.ConstantKeywordFieldMapper;
+import org.opensearch.index.mapper.ContextAwareGroupingFieldMapper;
 import org.opensearch.index.mapper.DataStreamFieldMapper;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.DerivedFieldMapper;
@@ -178,6 +179,7 @@ public static Map<String, Mapper.TypeParser> getMappers(List<MapperPlugin> mappe
         mappers.put(WildcardFieldMapper.CONTENT_TYPE, WildcardFieldMapper.PARSER);
         mappers.put(StarTreeMapper.CONTENT_TYPE, new StarTreeMapper.TypeParser());
         mappers.put(SemanticVersionFieldMapper.CONTENT_TYPE, SemanticVersionFieldMapper.PARSER);
+        mappers.put(ContextAwareGroupingFieldMapper.CONTENT_TYPE, ContextAwareGroupingFieldMapper.PARSER);
 
         for (MapperPlugin mapperPlugin : mapperPlugins) {
             for (Map.Entry<String, Mapper.TypeParser> entry : mapperPlugin.getMappers().entrySet()) {
diff --git a/server/src/main/java/org/opensearch/script/ContextAwareGroupingScript.java b/server/src/main/java/org/opensearch/script/ContextAwareGroupingScript.java
new file mode 100644
index 0000000000000..a0ca0de7a784c
--- /dev/null
+++ b/server/src/main/java/org/opensearch/script/ContextAwareGroupingScript.java
@@ -0,0 +1,44 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.script;
+
+import org.opensearch.common.unit.TimeValue;
+import org.opensearch.index.mapper.ContextAwareGroupingFieldMapper;
+
+import java.util.Map;
+
+/**
+ * A script used in {@link ContextAwareGroupingFieldMapper} which acts as grouping criteria function
+ * for context aware segments
+ *
+ * @opensearch.internal
+ */
+public abstract class ContextAwareGroupingScript {
+    public static final String[] PARAMETERS = { "ctx" };
+
+    /** The context used to compile {@link ContextAwareGroupingScript} factories. */
+    public static final ScriptContext<ContextAwareGroupingScript.Factory> CONTEXT = new ScriptContext<>(
+        ContextAwareGroupingFieldMapper.CONTENT_TYPE,
+        ContextAwareGroupingScript.Factory.class,
+        200,
+        TimeValue.timeValueMillis(10000),
+        ScriptCache.UNLIMITED_COMPILATION_RATE.asTuple()
+    );
+
+    public abstract String execute(Map<String, Object> ctx);
+
+    /**
+     * A factory to construct stateful {@link ContextAwareGroupingScript} factories for a specific index.
+     *
+     * @opensearch.internal
+     */
+    public interface Factory {
+        ContextAwareGroupingScript newInstance();
+    }
+}
diff --git a/server/src/main/java/org/opensearch/script/ScriptModule.java b/server/src/main/java/org/opensearch/script/ScriptModule.java
index c83a6e64d53eb..a28e296f0886f 100644
--- a/server/src/main/java/org/opensearch/script/ScriptModule.java
+++ b/server/src/main/java/org/opensearch/script/ScriptModule.java
@@ -79,7 +79,8 @@ public class ScriptModule {
             ScriptedMetricAggContexts.CombineScript.CONTEXT,
             ScriptedMetricAggContexts.ReduceScript.CONTEXT,
             IntervalFilterScript.CONTEXT,
-            DerivedFieldScript.CONTEXT
+            DerivedFieldScript.CONTEXT,
+            ContextAwareGroupingScript.CONTEXT
         ).collect(Collectors.toMap(c -> c.name, Function.identity()));
     }
 
diff --git a/server/src/test/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapperTests.java
new file mode 100644
index 0000000000000..e3368726a8bad
--- /dev/null
+++ b/server/src/test/java/org/opensearch/index/mapper/ContextAwareGroupingFieldMapperTests.java
@@ -0,0 +1,149 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.opensearch.common.settings.Settings;
+import org.opensearch.script.ContextAwareGroupingScript;
+import org.opensearch.script.Script;
+import org.opensearch.script.ScriptService;
+import org.opensearch.test.OpenSearchTestCase;
+import org.junit.Before;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static java.util.Collections.emptyMap;
+import static java.util.Collections.singletonList;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ContextAwareGroupingFieldMapperTests extends OpenSearchTestCase {
+
+    private ScriptService mockScriptService;
+    private Mapper.TypeParser.ParserContext mockParserContext;
+    private ObjectMapper.Builder mockObjectMapperBuilder;
+
+    @Before
+    public void setUp() throws Exception {
+        super.setUp();
+        // Set up mocks for dependencies
+        mockScriptService = mock(ScriptService.class);
+        mockParserContext = new Mapper.TypeParser.ParserContext(null, null, null, null, null, null, mockScriptService);
+        mockObjectMapperBuilder = new ObjectMapper.Builder("parent_field");
+    }
+
+    public void testValidFieldsMapping() throws Exception {
+        // Add a field to the mock ObjectMapper.Builder to satisfy the validation
+        mockObjectMapperBuilder.add(new KeywordFieldMapper.Builder("keyword_field"));
+
+        Map<String, Object> node = new HashMap<>();
+        List<String> fields = Collections.singletonList("keyword_field");
+        node.put("fields", fields);
+
+        ContextAwareGroupingFieldMapper.Builder builder = (ContextAwareGroupingFieldMapper.Builder) ContextAwareGroupingFieldMapper.PARSER
+            .parse("context_aware_grouping", node, mockParserContext, mockObjectMapperBuilder);
+
+        ContextAwareGroupingFieldMapper mapper = (ContextAwareGroupingFieldMapper) builder.build(
+            new Mapper.BuilderContext(Settings.EMPTY, new ContentPath(0))
+        );
+
+        assertEquals("context_aware_grouping", mapper.simpleName());
+        assertEquals(fields, mapper.fieldType().fields());
+        assertNull(mapper.fieldType().compiledScript());
+    }
+
+    public void testInvalidFieldsType() {
+        // Not a list
+        Map<String, Object> node1 = new HashMap<>();
+        node1.put("fields", "not_a_list");
+
+        MapperParsingException e = expectThrows(
+            MapperParsingException.class,
+            () -> ContextAwareGroupingFieldMapper.PARSER.parse("context_aware_grouping", node1, mockParserContext, mockObjectMapperBuilder)
+        );
+        assertTrue(e.getMessage().contains("Expected [fields] to be a list of strings but got [not_a_list]"));
+
+        // Multiple fields
+        Map<String, Object> node2 = new HashMap<>();
+        List<String> fields = List.of("keyword_field", "multi_field");
+        node2.put("fields", fields);
+
+        e = expectThrows(
+            MapperParsingException.class,
+            () -> ContextAwareGroupingFieldMapper.PARSER.parse("context_aware_grouping", node2, mockParserContext, mockObjectMapperBuilder)
+        );
+        assertTrue(e.getMessage().contains("Currently [fields] in context_aware_grouping does not support multiple values"));
+
+        // No fields
+        e = expectThrows(
+            MapperParsingException.class,
+            () -> ContextAwareGroupingFieldMapper.PARSER.parse(
+                "context_aware_grouping",
+                emptyMap(),
+                mockParserContext,
+                mockObjectMapperBuilder
+            )
+        );
+        assertTrue(e.getMessage().contains("[fields] in context_aware_grouping is required"));
+
+        // fields not present in properties of mapping
+        mockObjectMapperBuilder.add(new KeywordFieldMapper.Builder("keyword_field"));
+
+        Map<String, Object> node = new HashMap<>();
+        node.put("fields", Collections.singletonList("blah"));
+
+        e = expectThrows(
+            MapperParsingException.class,
+            () -> ContextAwareGroupingFieldMapper.PARSER.parse("context_aware_grouping", node, mockParserContext, mockObjectMapperBuilder)
+        );
+    }
+
+    public void testValidScriptMapping() {
+        mockObjectMapperBuilder.add(new KeywordFieldMapper.Builder("keyword_field"));
+        Map<String, Object> node = new HashMap<>();
+        Map<String, Object> scriptNode = new HashMap<>();
+        scriptNode.put("source", "return \"hello\";");
+        node.put("fields", singletonList("keyword_field"));
+        node.put("script", scriptNode);
+
+        ContextAwareGroupingScript.Factory mockFactory = mock(ContextAwareGroupingScript.Factory.class);
+        ContextAwareGroupingScript mockScript = mock(ContextAwareGroupingScript.class);
+
+        when(mockScriptService.compile(any(Script.class), eq(ContextAwareGroupingScript.CONTEXT))).thenReturn(mockFactory);
+        when(mockFactory.newInstance()).thenReturn(mockScript);
+
+        ContextAwareGroupingFieldMapper.Builder builder = (ContextAwareGroupingFieldMapper.Builder) ContextAwareGroupingFieldMapper.PARSER
+            .parse("context_aware_grouping", node, mockParserContext, mockObjectMapperBuilder);
+
+        ContextAwareGroupingFieldMapper mapper = (ContextAwareGroupingFieldMapper) builder.build(
+            new Mapper.BuilderContext(Settings.EMPTY, new ContentPath(0))
+        );
+
+        assertNotNull(mapper.fieldType().compiledScript());
+    }
+
+    public void testIngestAttemptThrowsException() {
+        ContextAwareGroupingFieldType fieldType = new ContextAwareGroupingFieldType(Collections.emptyList(), null);
+        ContextAwareGroupingFieldMapper mapper = new ContextAwareGroupingFieldMapper(
+            "context_aware_grouping",
+            fieldType,
+            new ContextAwareGroupingFieldMapper.Builder("context_aware_grouping")
+        );
+
+        // Mock a ParseContext
+        ParseContext mockParseContext = mock(ParseContext.class);
+
+        MapperParsingException e = expectThrows(MapperParsingException.class, () -> mapper.parseCreateField(mockParseContext));
+        assertTrue(e.getMessage().contains("context_aware_grouping cannot be ingested in the document"));
+    }
+}
diff --git a/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
index fb1325366452f..551fbd89e4e87 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DateFieldMapperTests.java
@@ -119,6 +119,35 @@ protected void assertParseMaximalWarnings() {
         assertWarnings("Parameter [boost] on field [field] is deprecated and will be removed in 3.0");
     }
 
+    public void testWithContextAwareGroupingMapper() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            contextAwareGrouping("field").accept(b);
+            properties(x -> {
+                x.startObject("field");
+                minimalMapping(x);
+                b.endObject();
+            }).accept(b);
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", "2016-03-11")));
+
+        // Assert date field
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(2, fields.length);
+        IndexableField pointField = fields[0];
+        assertEquals(1, pointField.fieldType().pointIndexDimensionCount());
+        assertEquals(8, pointField.fieldType().pointNumBytes());
+        assertFalse(pointField.fieldType().stored());
+        assertEquals(1457654400000L, pointField.numericValue().longValue());
+        IndexableField dvField = fields[1];
+        assertEquals(DocValuesType.SORTED_NUMERIC, dvField.fieldType().docValuesType());
+        assertEquals(1457654400000L, dvField.numericValue().longValue());
+        assertFalse(dvField.fieldType().stored());
+
+        // Assert groupingcriteria is correct
+        assertEquals("2016-03-11", doc.docs().getFirst().getGroupingCriteria());
+    }
+
     public void testDefaults() throws Exception {
 
         DocumentMapper mapper = createDocumentMapper(fieldMapping(this::minimalMapping));
diff --git a/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java b/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
index e9be8b671d7ba..5460ee8f2b326 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DocumentParserTests.java
@@ -2582,4 +2582,22 @@ public void testDynamicFalseAllowTemplatesWithNestedCopyTo() throws Exception {
         assertEquals(0, doc.rootDoc().getFields("nested.target_field").length);
     }
 
+    public void testGenerateGroupingCriteriaFromScript() throws Exception {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            contextAwareGrouping("status_code").accept(b);
+            properties(x -> {
+                x.startObject("status_code");
+                b.field("type", "integer");
+                b.endObject();
+            }).accept(b);
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> {
+            b.field("status_code", "300");
+            b.field("bar", 10);
+        }));
+
+        assertEquals("300", doc.docs().getFirst().getGroupingCriteria());
+    }
+
 }
diff --git a/server/src/test/java/org/opensearch/index/mapper/IpFieldMapperTests.java b/server/src/test/java/org/opensearch/index/mapper/IpFieldMapperTests.java
index f2202c217a76f..54399a31e4456 100644
--- a/server/src/test/java/org/opensearch/index/mapper/IpFieldMapperTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/IpFieldMapperTests.java
@@ -269,6 +269,32 @@ public void testDerivedValueFetching_StoredField() throws IOException {
         }
     }
 
+    public void testWithContextAwareGroupingMapper() throws IOException {
+        DocumentMapper mapper = createDocumentMapper(topMapping(b -> {
+            contextAwareGrouping("field").accept(b);
+            properties(x -> {
+                x.startObject("field");
+                minimalMapping(x);
+                b.endObject();
+            }).accept(b);
+        }));
+
+        ParsedDocument doc = mapper.parse(source(b -> b.field("field", "127.0.0.1")));
+
+        // Assert date field
+        IndexableField[] fields = doc.rootDoc().getFields("field");
+        assertEquals(1, fields.length);
+        IndexableField pointFieldAndDVField = fields[0];
+        assertEquals(1, pointFieldAndDVField.fieldType().pointIndexDimensionCount());
+        assertEquals(16, pointFieldAndDVField.fieldType().pointNumBytes());
+        assertFalse(pointFieldAndDVField.fieldType().stored());
+        assertEquals(new BytesRef(InetAddressPoint.encode(InetAddresses.forString("127.0.0.1"))), pointFieldAndDVField.binaryValue());
+        assertEquals(DocValuesType.SORTED_SET, pointFieldAndDVField.fieldType().docValuesType());
+
+        // Assert grouping criteria is correct
+        assertEquals("/127.0.0.1", doc.docs().getFirst().getGroupingCriteria());
+    }
+
     private IpFieldMapper getMapper(FieldMapper.CopyTo copyTo, boolean hasDocValues, boolean isStored) throws IOException {
         MapperService mapperService = createMapperService(
             fieldMapping(b -> b.field("type", "ip").field("store", isStored).field("doc_values", hasDocValues))
diff --git a/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java b/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
index 471ec8ce8b429..d7c572c0cf9a9 100644
--- a/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/index/mapper/MapperServiceTestCase.java
@@ -217,9 +217,9 @@ protected final void merge(MapperService mapperService, MapperService.MergeReaso
         mapperService.merge("_doc", new CompressedXContent(BytesReference.bytes(mapping)), reason);
     }
 
-    protected final XContentBuilder topMapping(CheckedConsumer<XContentBuilder, IOException> buildFields) throws IOException {
+    protected final XContentBuilder topMapping(CheckedConsumer<XContentBuilder, IOException> mapping) throws IOException {
         XContentBuilder builder = XContentFactory.jsonBuilder().startObject().startObject("_doc");
-        buildFields.accept(builder);
+        mapping.accept(builder);
         return builder.endObject().endObject();
     }
 
@@ -229,6 +229,23 @@ protected final XContentBuilder mapping(CheckedConsumer<XContentBuilder, IOExcep
         return builder.endObject().endObject().endObject();
     }
 
+    protected final CheckedConsumer<XContentBuilder, IOException> properties(CheckedConsumer<XContentBuilder, IOException> buildFields)
+        throws IOException {
+        return builder -> {
+            builder.startObject("properties");
+            buildFields.accept(builder);
+            builder.endObject();
+        };
+    }
+
+    protected final CheckedConsumer<XContentBuilder, IOException> contextAwareGrouping(String field) throws IOException {
+        return builder -> {
+            builder.startObject("context_aware_grouping");
+            builder.startArray("fields").value(field).endArray();
+            builder.endObject();
+        };
+    }
+
     protected final XContentBuilder derivedMapping(CheckedConsumer<XContentBuilder, IOException> buildFields) throws IOException {
         XContentBuilder builder = XContentFactory.jsonBuilder().startObject().startObject("_doc").startObject("derived");
         buildFields.accept(builder);
diff --git a/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java b/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
index 048f0acb60cde..0260e0cdd95fb 100644
--- a/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
+++ b/test/framework/src/main/java/org/opensearch/script/MockScriptEngine.java
@@ -321,6 +321,14 @@ public void execute() {
                 }
             };
             return context.factoryClazz.cast(factory);
+        } else if (context.instanceClazz.equals(ContextAwareGroupingScript.class)) {
+            ContextAwareGroupingScript.Factory factory = () -> new ContextAwareGroupingScript() {
+                @Override
+                public String execute(Map<String, Object> ctx) {
+                    return (String) script.apply(ctx);
+                }
+            };
+            return context.factoryClazz.cast(factory);
         }
 
         ContextCompiler compiler = contexts.get(context);
diff --git a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
index 9bb5e38045368..c7de8388981c3 100644
--- a/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
+++ b/test/framework/src/main/java/org/opensearch/search/aggregations/AggregatorTestCase.java
@@ -103,6 +103,7 @@
 import org.opensearch.index.mapper.CompositeMappedFieldType;
 import org.opensearch.index.mapper.ConstantKeywordFieldMapper;
 import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.ContextAwareGroupingFieldMapper;
 import org.opensearch.index.mapper.DateFieldMapper;
 import org.opensearch.index.mapper.DerivedFieldMapper;
 import org.opensearch.index.mapper.FieldAliasMapper;
@@ -217,6 +218,7 @@ public abstract class AggregatorTestCase extends OpenSearchTestCase {
         denylist.add(DerivedFieldMapper.CONTENT_TYPE); // TODO support derived fields
         denylist.add(StarTreeMapper.CONTENT_TYPE); // TODO evaluate support for star tree fields
         denylist.add(SemanticVersionFieldMapper.CONTENT_TYPE); // TODO support for semantic version fields
+        denylist.add(ContextAwareGroupingFieldMapper.CONTENT_TYPE); // Cannot aggregate context aware groupings
         TYPE_TEST_DENYLIST = denylist;
     }