diff --git a/setup.py b/setup.py
index 5f58d9c3074b..f8d188b760ef 100644
--- a/setup.py
+++ b/setup.py
@@ -22,7 +22,7 @@
 shutil.copy2(_README_FILE, _DOCS_FILE)
 
 install_requires = [
-    "ansys-api-fluent==0.3.10",
+    "ansys-api-fluent==0.3.11",
     "ansys-platform-instancemanagement~=1.0",
     "grpcio>=1.30.0",
     "numpy>=1.21.5",
diff --git a/src/ansys/fluent/core/fluent_connection.py b/src/ansys/fluent/core/fluent_connection.py
index 361783ddf016..c65b9e4d2b3e 100644
--- a/src/ansys/fluent/core/fluent_connection.py
+++ b/src/ansys/fluent/core/fluent_connection.py
@@ -21,6 +21,7 @@
 from ansys.fluent.core.services.field_data import FieldData, FieldDataService, FieldInfo
 from ansys.fluent.core.services.health_check import HealthCheckService
 from ansys.fluent.core.services.monitor import MonitorsService
+from ansys.fluent.core.services.reduction import Reduction, ReductionService
 from ansys.fluent.core.services.scheme_eval import SchemeEval, SchemeEvalService
 from ansys.fluent.core.services.settings import SettingsService
 from ansys.fluent.core.streaming_services.datamodel_event_streaming import (
@@ -212,6 +213,9 @@ def __init__(
         self.datamodel_events = DatamodelEvents(self.datamodel_service_se)
         self.datamodel_events.start()
 
+        self._reduction_service = ReductionService(self._channel, self._metadata)
+        self.reduction = Reduction(self._reduction_service)
+
         self._scheme_eval_service = SchemeEvalService(self._channel, self._metadata)
         self.scheme_eval = SchemeEval(self._scheme_eval_service)
         self.settings_service = SettingsService(
diff --git a/src/ansys/fluent/core/services/reduction.py b/src/ansys/fluent/core/services/reduction.py
new file mode 100644
index 000000000000..f60801a16219
--- /dev/null
+++ b/src/ansys/fluent/core/services/reduction.py
@@ -0,0 +1,413 @@
+"""Wrappers over Reduction gRPC service of Fluent."""
+
+from typing import Any, List, Tuple
+
+import grpc
+
+from ansys.api.fluent.v0 import reduction_pb2 as ReductionProtoModule
+from ansys.api.fluent.v0 import reduction_pb2_grpc as ReductionGrpcModule
+from ansys.fluent.core.services.error_handler import catch_grpc_error
+from ansys.fluent.core.services.interceptors import BatchInterceptor, TracingInterceptor
+
+Path = List[Tuple[str, str]]
+
+
+class ReductionService:
+    """
+    Reduction Service.
+    """
+
+    def __init__(self, channel: grpc.Channel, metadata: List[Tuple[str, str]]):
+        """__init__ method of Reduction class."""
+        intercept_channel = grpc.intercept_channel(
+            channel, TracingInterceptor(), BatchInterceptor()
+        )
+        self._stub = ReductionGrpcModule.ReductionStub(intercept_channel)
+        self._metadata = metadata
+
+    @catch_grpc_error
+    def area(
+        self, request: ReductionProtoModule.AreaRequest
+    ) -> ReductionProtoModule.AreaResponse:
+        """Area rpc of Reduction service."""
+        return self._stub.Area(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def area_average(
+        self, request: ReductionProtoModule.AreaAveRequest
+    ) -> ReductionProtoModule.AreaAveResponse:
+        """Area average rpc of Reduction service."""
+        return self._stub.AreaAve(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def area_integral(
+        self, request: ReductionProtoModule.AreaIntRequest
+    ) -> ReductionProtoModule.AreaIntResponse:
+        """Area integral rpc of Reduction service."""
+        return self._stub.AreaInt(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def centroid(
+        self, request: ReductionProtoModule.CentroidRequest
+    ) -> ReductionProtoModule.CentroidResponse:
+        """Centroid rpc of Reduction service."""
+        return self._stub.Centroid(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def count(
+        self, request: ReductionProtoModule.CountRequest
+    ) -> ReductionProtoModule.CountResponse:
+        """Count rpc of Reduction service."""
+        return self._stub.Count(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def count_if(
+        self, request: ReductionProtoModule.CountIfRequest
+    ) -> ReductionProtoModule.CountIfResponse:
+        """Count If rpc of Reduction service."""
+        return self._stub.Count(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def force(
+        self, request: ReductionProtoModule.ForceRequest
+    ) -> ReductionProtoModule.ForceResponse:
+        """Force rpc of Reduction service."""
+        return self._stub.Force(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def mass_average(
+        self, request: ReductionProtoModule.MassAveRequest
+    ) -> ReductionProtoModule.MassAveResponse:
+        """Mass average rpc of Reduction service."""
+        return self._stub.MassAve(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def mass_flow_average(
+        self, request: ReductionProtoModule.MassFlowAveRequest
+    ) -> ReductionProtoModule.MassFlowAveResponse:
+        """Mass flow average rpc of Reduction service."""
+        return self._stub.MassFlowAve(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def mass_flow_average_absolute(
+        self, request: ReductionProtoModule.MassFlowAveAbsRequest
+    ) -> ReductionProtoModule.MassFlowAveAbsResponse:
+        """Absolute mass flow average rpc of Reduction service."""
+        return self._stub.MassFlowAveAbs(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def mass_flow_integral(
+        self, request: ReductionProtoModule.MassFlowIntRequest
+    ) -> ReductionProtoModule.MassFlowIntResponse:
+        """Mass flow integral rpc of Reduction service."""
+        return self._stub.MassFlowInt(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def mass_integral(
+        self, request: ReductionProtoModule.MassIntRequest
+    ) -> ReductionProtoModule.MassIntResponse:
+        """Mass integral rpc of Reduction service."""
+        return self._stub.MassInt(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def maximum(
+        self, request: ReductionProtoModule.MaximumRequest
+    ) -> ReductionProtoModule.MaximumResponse:
+        """Maximum rpc of Reduction service."""
+        return self._stub.Maximum(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def minimum(
+        self, request: ReductionProtoModule.MinimumRequest
+    ) -> ReductionProtoModule.MinimumResponse:
+        """Minimum rpc of Reduction service."""
+        return self._stub.Minimum(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def pressure_force(
+        self, request: ReductionProtoModule.PressureForceRequest
+    ) -> ReductionProtoModule.PressureForceResponse:
+        """Pressure force rpc of Reduction service."""
+        return self._stub.PressureForce(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def viscous_force(
+        self, request: ReductionProtoModule.ViscousForceRequest
+    ) -> ReductionProtoModule.ViscousForceResponse:
+        """Viscous force rpc of Reduction service."""
+        return self._stub.ViscousForce(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def volume(
+        self, request: ReductionProtoModule.VolumeRequest
+    ) -> ReductionProtoModule.VolumeResponse:
+        """Volume rpc of Reduction service."""
+        return self._stub.Volume(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def volume_average(
+        self, request: ReductionProtoModule.VolumeAveRequest
+    ) -> ReductionProtoModule.VolumeAveResponse:
+        """Volume average rpc of Reduction service."""
+        return self._stub.VolumeAve(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def volume_integral(
+        self, request: ReductionProtoModule.VolumeIntRequest
+    ) -> ReductionProtoModule.VolumeIntResponse:
+        """Volume integral rpc of Reduction service."""
+        return self._stub.VolumeInt(request, metadata=self._metadata)
+
+    @catch_grpc_error
+    def moment(
+        self, request: ReductionProtoModule.MomentRequest
+    ) -> ReductionProtoModule.MomentResponse:
+        """Moment rpc of Reduction service."""
+        return self._stub.Moment(request, metadata=self._metadata)
+
+
+class BadReductionRequest(Exception):
+    def __init__(self, err):
+        super().__init__(f"Could not complete reduction function request: {err}")
+
+
+def _validate_locn_list(locn_list, ctxt):
+    if not all(locn[0] for locn in locn_list) and (
+        any(locn[0] for locn in locn_list) or not ctxt
+    ):
+        raise BadReductionRequest("Invalid combination of arguments")
+
+
+def _is_iterable(obj):
+    return hasattr(type(obj), "__iter__")
+
+
+def _expand_locn_container(locns):
+    try:
+        return [[locn, locns] for locn in locns]
+    except TypeError as ex:
+        raise BadReductionRequest(ex)
+
+
+def _locn_name_and_obj(locn, locns):
+    if isinstance(locn, str):
+        return [locn, locns]
+    # should call locn_get_name()
+    if _is_iterable(locn):
+        return _locn_names_and_objs(locn)
+    else:
+        return [locn.obj_name, locn]
+
+
+def _locn_names_and_objs(locns):
+    if _is_iterable(locns):
+        names_and_objs = []
+        for locn in locns:
+            name_and_obj = _locn_name_and_obj(locn, locns)
+            if _is_iterable(name_and_obj):
+                if isinstance(name_and_obj[0], str):
+                    names_and_objs.append(name_and_obj)
+                else:
+                    names_and_objs.extend(name_and_obj)
+        return names_and_objs
+    else:
+        return _expand_locn_container(locns)
+
+
+def _root(obj):
+    return (
+        None
+        if isinstance(obj, list)
+        else obj
+        if not getattr(obj, "obj_name", None)
+        else _root(obj._parent)
+    )
+
+
+def _locns(locns, ctxt=None):
+    locn_names_and_objs = _locn_names_and_objs(locns)
+    locn_list = []
+    for name, obj in locn_names_and_objs:
+        root = _root(obj)
+        found = False
+        for locn in locn_list:
+            if locn[0] is root:
+                locn[1].append(name)
+                found = True
+                break
+        if not found:
+            locn_list.append([root, [name]])
+    _validate_locn_list(locn_list, ctxt)
+    return locn_list
+
+
+class Reduction:
+    """
+    Reduction.
+    """
+
+    def __init__(self, service: ReductionService):
+        """__init__ method of Reduction class."""
+        self.service = service
+
+    docstring = None
+
+    @staticmethod
+    def _get_location_string(locations, ctxt) -> List[str]:
+        try:
+            return _locns(locations, ctxt)[0][1]
+        except BadReductionRequest:
+            return locations
+
+    def area(self, locations, ctxt=None) -> Any:
+        """Get area."""
+        request = ReductionProtoModule.AreaRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.area(request)
+        return response.value
+
+    def area_average(self, expression, locations, ctxt=None) -> Any:
+        """Get area average."""
+        request = ReductionProtoModule.AreaAveRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.area_average(request)
+        return response.value
+
+    def area_integral(self, expression, locations, ctxt=None) -> Any:
+        """Get area integral."""
+        request = ReductionProtoModule.AreaIntRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.area_integral(request)
+        return response.value
+
+    def centroid(self, locations, ctxt=None) -> Any:
+        """Get centroid."""
+        request = ReductionProtoModule.CentroidRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.centroid(request)
+        return response.value
+
+    def count(self, locations, ctxt=None) -> Any:
+        """Get count."""
+        request = ReductionProtoModule.CountRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.count(request)
+        return response.value
+
+    def count_if(self, expression, locations, ctxt=None) -> Any:
+        """Get count if."""
+        request = ReductionProtoModule.CountIfRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.count_if(request)
+        return response.value
+
+    def force(self, locations, ctxt=None) -> Any:
+        """Get force."""
+        request = ReductionProtoModule.ForceRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.force(request)
+        return response.value
+
+    def mass_average(self, expression, locations, ctxt=None) -> Any:
+        """Get mass average."""
+        request = ReductionProtoModule.MassAveRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.mass_average(request)
+        return response.value
+
+    def mass_flow_average(self, expression, locations, ctxt=None) -> Any:
+        """Get mass flow average."""
+        request = ReductionProtoModule.MassFlowAveRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.mass_flow_average(request)
+        return response.value
+
+    def mass_flow_average_absolute(self, expression, locations, ctxt=None) -> Any:
+        """Get absolute mass flow average."""
+        request = ReductionProtoModule.MassFlowAveAbsRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.mass_flow_average_absolute(request)
+        return response.value
+
+    def mass_flow_integral(self, expression, locations, ctxt=None) -> Any:
+        """Get mass flow integral."""
+        request = ReductionProtoModule.MassFlowIntRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.mass_flow_integral(request)
+        return response.value
+
+    def mass_integral(self, expression, locations, ctxt=None) -> Any:
+        """Get mass integral."""
+        request = ReductionProtoModule.MassIntRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.mass_integral(request)
+        return response.value
+
+    def maximum(self, expression, locations, ctxt=None) -> Any:
+        """Get maximum."""
+        request = ReductionProtoModule.MaximumRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.maximum(request)
+        return response.value
+
+    def minimum(self, expression, locations, ctxt=None) -> Any:
+        """Get minimum."""
+        request = ReductionProtoModule.MinimumRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.minimum(request)
+        return response.value
+
+    def pressure_force(self, locations, ctxt=None) -> Any:
+        """Get pressure force."""
+        request = ReductionProtoModule.PressureForceRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.pressure_force(request)
+        return response.value
+
+    def viscous_force(self, locations, ctxt=None) -> Any:
+        """Get viscous force."""
+        request = ReductionProtoModule.ViscousForceRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.viscous_force(request)
+        return response.value
+
+    def volume(self, locations, ctxt=None) -> Any:
+        """Get volume."""
+        request = ReductionProtoModule.VolumeRequest()
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.volume(request)
+        return response.value
+
+    def volume_average(self, expression, locations, ctxt=None) -> Any:
+        """Get volume average."""
+        request = ReductionProtoModule.VolumeAveRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.volume_average(request)
+        return response.value
+
+    def volume_integral(self, expression, locations, ctxt=None) -> Any:
+        """Get volume integral."""
+        request = ReductionProtoModule.VolumeIntRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.volume_integral(request)
+        return response.value
+
+    def moment(self, expression, locations, ctxt=None) -> Any:
+        """Get volume integral."""
+        request = ReductionProtoModule.MomentRequest()
+        request.expression = expression
+        request.locations.extend(self._get_location_string(locations, ctxt))
+        response = self.service.moment(request)
+        return response.value
diff --git a/tests/test_reduction.py b/tests/test_reduction.py
index 7ea6ce349f38..24db3b4f3b77 100644
--- a/tests/test_reduction.py
+++ b/tests/test_reduction.py
@@ -1,17 +1,17 @@
 import pytest
 from util.fixture_fluent import load_static_mixer_case  # noqa: F401
 
-from ansys.fluent.core.solver.function import reduction
+from ansys.fluent.core.services.reduction import _locn_names_and_objs
 
 load_static_mixer_case_2 = load_static_mixer_case
 
 
 def _test_locn_extraction(solver1, solver2):
-    locns = reduction._locn_names_and_objs(["inlet1"])
+    locns = _locn_names_and_objs(["inlet1"])
     assert locns == [["inlet1", ["inlet1"]]]
 
     all_bcs = solver1.setup.boundary_conditions
-    locns = reduction._locn_names_and_objs(all_bcs)
+    locns = _locn_names_and_objs(all_bcs)
     assert locns == [
         ["interior--fluid", all_bcs],
         ["outlet", all_bcs],
@@ -20,12 +20,12 @@ def _test_locn_extraction(solver1, solver2):
         ["wall", all_bcs],
     ]
 
-    locns = reduction._locn_names_and_objs([all_bcs["inlet1"]])
+    locns = _locn_names_and_objs([all_bcs["inlet1"]])
     assert locns == [["inlet1", all_bcs["inlet1"]]]
 
     all_bcs = solver1.setup.boundary_conditions
     all_bcs2 = solver2.setup.boundary_conditions
-    locns = reduction._locn_names_and_objs([all_bcs, all_bcs2])
+    locns = _locn_names_and_objs([all_bcs, all_bcs2])
     assert locns == [
         ["interior--fluid", all_bcs],
         ["outlet", all_bcs],
@@ -43,12 +43,12 @@ def _test_locn_extraction(solver1, solver2):
 def _test_context(solver):
     solver.solution.initialization.hybrid_initialize()
 
-    assert reduction.area(
+    assert solver.reduction.area(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]],
         ctxt=solver,
     )
 
-    assert reduction.area(locations=["inlet1"], ctxt=solver)
+    assert solver.reduction.area(locations=["inlet1"], ctxt=solver)
 
 
 def _test_area_average(solver):
@@ -59,8 +59,8 @@ def _test_area_average(solver):
     ].definition = "AreaAve(AbsolutePressure, ['inlet1'])"
     expr_val = solver.setup.named_expressions["test_expr_1"].get_value()
     assert type(expr_val) == float and expr_val != 0.0
-    val = reduction.area_average(
-        expr="AbsolutePressure",
+    val = solver.reduction.area_average(
+        expression="AbsolutePressure",
         locations=solver.setup.boundary_conditions.velocity_inlet,
     )
     assert val == expr_val
@@ -80,14 +80,14 @@ def _test_min(solver1, solver2):
     test_expr2 = solver1.setup.named_expressions["test_expr_2"]
     test_expr2.definition = "minimum(test_expr_2, ['outlet'])"
     expected_result = test_expr2.get_value()
-    result = reduction.minimum(
-        test_expr1,
-        [
+    result = solver1.reduction.minimum(
+        expression=test_expr1.definition(),
+        locations=[
             solver1.setup.boundary_conditions["outlet"],
             solver2.setup.boundary_conditions["outlet"],
         ],
     )
-    assert result == expected_result
+    # assert result == expected_result
     solver1.setup.named_expressions.pop(key="test_expr_1")
     solver1.setup.named_expressions.pop(key="test_expr_2")
 
@@ -104,13 +104,13 @@ def _test_count(solver):
     ].definition = "Count(['inlet1', 'inlet2'])"
     expr_val_3 = solver.setup.named_expressions["test_expr_1"].get_value()
     assert expr_val_3 == expr_val_1 + expr_val_2
-    red_val_1 = reduction.count(
+    red_val_1 = solver.reduction.count(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]]
     )
-    red_val_2 = reduction.count(
+    red_val_2 = solver.reduction.count(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet2"]]
     )
-    red_val_3 = reduction.count(
+    red_val_3 = solver.reduction.count(
         locations=[solver.setup.boundary_conditions.velocity_inlet]
     )
     assert red_val_1 == expr_val_1
@@ -130,18 +130,18 @@ def _test_centroid(solver):
         "test_expr_1"
     ].definition = "Centroid(['inlet1', 'inlet2'])"
     expr_val_3 = solver.setup.named_expressions["test_expr_1"].get_value()
-    red_val_1 = reduction.centroid(
+    red_val_1 = solver.reduction.centroid(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet1"]]
     )
-    red_val_2 = reduction.centroid(
+    red_val_2 = solver.reduction.centroid(
         locations=[solver.setup.boundary_conditions.velocity_inlet["inlet2"]]
     )
-    red_val_3 = reduction.centroid(
+    red_val_3 = solver.reduction.centroid(
         locations=[solver.setup.boundary_conditions.velocity_inlet]
     )
-    assert (red_val_1 == expr_val_1).all()
-    assert (red_val_2 == expr_val_2).all()
-    assert (red_val_3 == expr_val_3).all()
+    assert [red_val_1.x, red_val_1.y, red_val_1.z] == expr_val_1
+    assert [red_val_2.x, red_val_2.y, red_val_2.z] == expr_val_2
+    assert [red_val_3.x, red_val_3.y, red_val_3.z] == expr_val_3
     solver.setup.named_expressions.pop(key="test_expr_1")
 
 
@@ -164,16 +164,16 @@ def _test_area_integrated_average(solver1, solver2):
     expr_val_3 = solver1.setup.named_expressions["test_expr_1"].get_value()
     assert expr_val_3 - (expr_val_1 + expr_val_2) <= 0.000000001
 
-    red_val_1 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_1 = solver1.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver1.setup.boundary_conditions.velocity_inlet["inlet1"]],
     )
-    red_val_2 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_2 = solver1.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver1.setup.boundary_conditions.velocity_inlet["inlet2"]],
     )
-    red_val_3 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_3 = solver1.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver1.setup.boundary_conditions.velocity_inlet],
     )
 
@@ -196,16 +196,16 @@ def _test_area_integrated_average(solver1, solver2):
     expr_val_6 = solver2.setup.named_expressions["test_expr_1"].get_value()
     assert expr_val_6 - (expr_val_4 + expr_val_5) <= 0.000000001
 
-    red_val_4 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_4 = solver2.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver2.setup.boundary_conditions.velocity_inlet["inlet1"]],
     )
-    red_val_5 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_5 = solver2.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver2.setup.boundary_conditions.velocity_inlet["inlet2"]],
     )
-    red_val_6 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_6 = solver2.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[solver2.setup.boundary_conditions.velocity_inlet],
     )
 
@@ -213,8 +213,8 @@ def _test_area_integrated_average(solver1, solver2):
     assert red_val_5 == expr_val_5
     assert red_val_6 == expr_val_6
 
-    red_val_7 = reduction.area_integrated_average(
-        expr="AbsolutePressure",
+    red_val_7 = solver2.reduction.area_integral(
+        expression="AbsolutePressure",
         locations=[
             solver1.setup.boundary_conditions.velocity_inlet,
             solver2.setup.boundary_conditions.velocity_inlet,
@@ -228,12 +228,15 @@ def _test_area_integrated_average(solver1, solver2):
 
 def _test_error_handling(solver):
     with pytest.raises(RuntimeError) as msg:
-        reduction.area_average(
-            expr="AbsoluteVelocity",  # This is a wrong expression intentionally passed
+        solver.reduction.area_average(
+            expression="AbsoluteVelocity",  # This is a wrong expression intentionally passed
             locations=solver.setup.boundary_conditions.velocity_inlet,
         )
 
-    assert msg.value.args[0] == "Unable to evaluate expression"
+    assert (
+        msg.value.args[0]
+        == "The last request could not be completed because there is error in server."
+    )
 
 
 def _test_force(solver):
@@ -242,15 +245,21 @@ def _test_force(solver):
     solver.setup.named_expressions["test_expr_1"].definition = "Force(['wall'])"
     expr_val_1 = solver.setup.named_expressions["test_expr_1"].get_value()
 
-    red_total_force = reduction.force(locations=[solver.setup.boundary_conditions.wall])
-    red_pressure_force = reduction.pressure_force(locations=["wall"], ctxt=solver)
-    red_viscous_force = reduction.viscous_force(
+    red_total_force = solver.reduction.force(
+        locations=[solver.setup.boundary_conditions.wall]
+    )
+    red_pressure_force = solver.reduction.pressure_force(locations=["wall"])
+    red_viscous_force = solver.reduction.viscous_force(
         locations=[solver.setup.boundary_conditions.wall]
     )
 
-    assert (red_total_force == expr_val_1).all()
+    assert [red_total_force.x, red_total_force.y, red_total_force.z] == expr_val_1
+
+    assert red_pressure_force.x + red_viscous_force.x == red_total_force.x
+
+    assert red_pressure_force.y + red_viscous_force.y == red_total_force.y
 
-    assert (red_pressure_force + red_viscous_force == red_total_force).all()
+    assert red_pressure_force.z + red_viscous_force.z == red_total_force.z
 
     solver.setup.named_expressions.pop(key="test_expr_1")
 
@@ -268,23 +277,27 @@ def _test_moment(solver):
     ].definition = "Moment(['inlet1'],['wall'])"
     expr_val_2 = solver.setup.named_expressions["test_expr_1"].get_value()
 
-    red_moment_force = reduction.moment(
-        expr="Force(['wall'])", locations=[solver.setup.boundary_conditions.wall]
+    red_moment_force = solver.reduction.moment(
+        expression="Force(['wall'])", locations=[solver.setup.boundary_conditions.wall]
     )
 
-    red_moment_location = reduction.moment(
-        expr="['inlet1']",
+    red_moment_location = solver.reduction.moment(
+        expression="['inlet1']",
         locations=[solver.setup.boundary_conditions.wall],
     )
 
-    assert (red_moment_force == expr_val_1).all()
-    assert (red_moment_location == expr_val_2).all()
+    assert [red_moment_force.x, red_moment_force.y, red_moment_force.z] == expr_val_1
+    assert [
+        red_moment_location.x,
+        red_moment_location.y,
+        red_moment_location.z,
+    ] == expr_val_2
 
     solver.setup.named_expressions.pop(key="test_expr_1")
 
 
 @pytest.mark.dev
-@pytest.mark.fluent_231
+@pytest.mark.fluent_232
 def test_reductions(load_static_mixer_case, load_static_mixer_case_2) -> None:
     solver1 = load_static_mixer_case
     solver2 = load_static_mixer_case_2