ibm-watsonx-gov 1.3.3__cp313-cp313-win_amd64.whl

ibm_watsonx_gov/metric_groups/readability/readability_decorator.py

@@ -0,0 +1,59 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields, MetricGroup
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics import TextGradeLevelMetric, TextReadingEaseMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class ReadabilityDecorator(BaseMetricDecorator):
+    def evaluate_readability(self,
+                             func: Optional[Callable] = None,
+                             *,
+                             configuration: Optional[AgenticAIConfiguration] = None,
+                             metrics: list[GenAIMetric] = []
+                             ) -> dict:
+        """
+        An evaluation decorator for computing readability metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_readability, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = MetricGroup.READABILITY.get_metrics()
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(TextGradeLevelMetric, TextReadingEaseMetric,))
+
+                metric_outputs = [EvaluatorFields.OUTPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=[],
+                                                      metric_outputs=metric_outputs,
+                                                      metric_groups=[MetricGroup.READABILITY])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating readability metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metric_groups/retrieval_quality/retrieval_quality_decorator.py

@@ -0,0 +1,63 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields, MetricGroup
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics import (AveragePrecisionMetric,
+                                     ContextRelevanceMetric, HitRateMetric,
+                                     NDCGMetric, ReciprocalRankMetric,
+                                     RetrievalPrecisionMetric)
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class RetrievalQualityDecorator(BaseMetricDecorator):
+    def evaluate_retrieval_quality(self,
+                                   func: Optional[Callable] = None,
+                                   *,
+                                   configuration: Optional[AgenticAIConfiguration] = None,
+                                   metrics: list[GenAIMetric] = []
+                                   ) -> dict:
+        """
+        An evaluation decorator for computing retrieval quality metrics on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_retrieval_quality, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = MetricGroup.RETRIEVAL_QUALITY.get_metrics()
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(NDCGMetric, ContextRelevanceMetric, ReciprocalRankMetric, RetrievalPrecisionMetric, AveragePrecisionMetric, HitRateMetric))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+                metric_outputs = [EvaluatorFields.CONTEXT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=metric_outputs,
+                                                      metric_groups=[MetricGroup.RETRIEVAL_QUALITY])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating retrieval quality metrics on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metric_groups/usage/usage_decorator.py

@@ -0,0 +1,58 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields, MetricGroup
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics import CostMetric, InputTokenCountMetric, OutputTokenCountMetric
+
+
+class UsageDecorator(BaseMetricDecorator):
+    def evaluate_usage(self,
+                       func: Optional[Callable] = None,
+                       *,
+                       configuration: Optional[AgenticAIConfiguration] = None,
+                       metrics: list[GenAIMetric] = []
+                       ) -> dict:
+        """
+        An evaluation decorator for computing usage metric on an agent invocation.
+        """
+        if func is None:
+            return partial(self.evaluate_usage, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = MetricGroup.USAGE.get_metrics()
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(CostMetric, InputTokenCountMetric, OutputTokenCountMetric))
+
+                metric_inputs = [EvaluatorFields.MODEL_USAGE_DETAIL_FIELDS,
+                                 EvaluatorFields.INPUT_TOKEN_COUNT_FIELDS, EvaluatorFields.OUTPUT_TOKEN_COUNT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating usage metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/__init__.py

@@ -0,0 +1,74 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+
+from typing import Annotated, Union
+
+from pydantic import Field
+
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+
+from .answer_relevance.answer_relevance_metric import AnswerRelevanceMetric
+from .answer_similarity.answer_similarity_metric import AnswerSimilarityMetric
+from .average_precision.average_precision_metric import AveragePrecisionMetric
+from .cost.cost_metric import CostMetric
+from .duration.duration_metric import DurationMetric
+from .evasiveness.evasiveness_metric import EvasivenessMetric
+from .faithfulness.faithfulness_metric import FaithfulnessMetric
+from .hap.hap_metric import HAPMetric
+from .hap.input_hap_metric import InputHAPMetric
+from .hap.output_hap_metric import OutputHAPMetric
+from .harm.harm_metric import HarmMetric
+from .harm_engagement.harm_engagement_metric import HarmEngagementMetric
+from .hit_rate.hit_rate_metric import HitRateMetric
+from .input_token_count.input_token_count_metric import InputTokenCountMetric
+from .jailbreak.jailbreak_metric import JailbreakMetric
+from .keyword_detection.keyword_detection_metric import KeywordDetectionMetric
+from .llm_validation.llm_validation_metric import LLMValidationMetric
+from .llmaj.llmaj_metric import LLMAsJudgeMetric
+from .ndcg.ndcg_metric import NDCGMetric
+from .output_token_count.output_token_count_metric import \
+    OutputTokenCountMetric
+from .pii.input_pii_metric import InputPIIMetric
+from .pii.output_pii_metric import OutputPIIMetric
+from .pii.pii_metric import PIIMetric
+from .profanity.profanity_metric import ProfanityMetric
+from .prompt_safety_risk.prompt_safety_risk_metric import \
+    PromptSafetyRiskMetric
+from .reciprocal_rank.reciprocal_rank_metric import ReciprocalRankMetric
+from .regex_detection.regex_detection_metric import RegexDetectionMetric
+from .retrieval_precision.retrieval_precision_metric import \
+    RetrievalPrecisionMetric
+from .sexual_content.sexual_content_metric import SexualContentMetric
+from .social_bias.social_bias_metric import SocialBiasMetric
+from .status.status_metric import StatusMetric
+from .text_grade_level.text_grade_level_metric import TextGradeLevelMetric
+from .text_reading_ease.text_reading_ease_metric import TextReadingEaseMetric
+from .tool_call_accuracy.tool_call_accuracy_metric import \
+    ToolCallAccuracyMetric
+from .tool_call_parameter_accuracy.tool_call_parameter_accuracy_metric import \
+    ToolCallParameterAccuracyMetric
+from .tool_call_relevance.tool_call_relevance_metric import \
+    ToolCallRelevanceMetric
+from .tool_call_syntactic_accuracy.tool_call_syntactic_accuracy_metric import \
+    ToolCallSyntacticAccuracyMetric
+from .topic_relevance.topic_relevance_metric import TopicRelevanceMetric
+from .unethical_behavior.unethical_behavior_metric import \
+    UnethicalBehaviorMetric
+from .unsuccessful_requests.unsuccessful_requests_metric import \
+    UnsuccessfulRequestsMetric
+from .user_id.user_id_metric import UserIdMetric
+from .violence.violence_metric import ViolenceMetric
+
+from .context_relevance.context_relevance_metric import ContextRelevanceMetric  # isort:skip
+
+METRICS_UNION = Annotated[Union[
+    tuple([c for c in GenAIMetric.__subclasses__() if c is not LLMAsJudgeMetric])
+], Field(
+    discriminator="name")]

ibm_watsonx_gov/metrics/answer_relevance/__init__.py

@@ -0,0 +1,8 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------

ibm_watsonx_gov/metrics/answer_relevance/answer_relevance_decorator.py

@@ -0,0 +1,63 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.answer_relevance.answer_relevance_metric import \
+    AnswerRelevanceMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class AnswerRelevanceDecorator(BaseMetricDecorator):
+    def evaluate_answer_relevance(self,
+                                  func: Optional[Callable] = None,
+                                  *,
+                                  configuration: Optional[AgenticAIConfiguration] = None,
+                                  metrics: list[GenAIMetric] = []
+                                  ) -> dict:
+        """
+        An evaluation decorator for computing answer relevance metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_answer_relevance, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [AnswerRelevanceMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(AnswerRelevanceMetric))
+
+                metric_inputs = [
+                    EvaluatorFields.INPUT_FIELDS
+                ]
+                metric_outputs = [EvaluatorFields.OUTPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=metric_outputs)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating answer relevance metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/answer_relevance/answer_relevance_metric.py

@@ -0,0 +1,260 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from typing import Annotated, Literal
+
+import pandas as pd
+from lazy_imports import LazyModule, load
+from pydantic import Field, model_validator
+from typing_extensions import Self
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration, GenAIConfiguration
+from ibm_watsonx_gov.entities.base_classes import Error
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import (AggregateMetricResult,
+                                                        RecordMetricResult)
+from ibm_watsonx_gov.entities.llm_judge import LLMJudge
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.detectors_provider import DetectorsProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.gov_sdk_logger import GovSDKLogger
+from ibm_watsonx_gov.utils.validation_util import (validate_input,
+                                                   validate_llm_as_judge,
+                                                   validate_output,
+                                                   validate_small_model_method,
+                                                   validate_unitxt_method)
+
+# Create lazy module for Unitxt imports
+unitxt_provider = LazyModule(
+    "from ibm_watsonx_gov.providers.unitxt_provider import UnitxtColumnMapping",
+    "from ibm_watsonx_gov.providers.unitxt_provider import UnitxtProvider",
+    name="lazy_unitxt_provider"
+)
+load(unitxt_provider)
+UnitxtColumnMapping = unitxt_provider.UnitxtColumnMapping
+UnitxtProvider = unitxt_provider.UnitxtProvider
+
+logger = GovSDKLogger.get_logger(__name__)
+ANSWER_RELEVANCE = "answer_relevance"
+UNITXT_METRIC_NAME = ANSWER_RELEVANCE
+unitxt_methods = [
+    "token_recall",
+    "llm_as_judge",
+    "granite_guardian",
+    "answer_relevance_model"
+]
+
+
+class AnswerRelevanceMetric(GenAIMetric):
+    """
+    Defines the Answer Relevance metric class.
+
+    The Answer Relevance metric measures the relevance of the generated text to the given input query.
+    It can be computed using the below methods:
+
+    1. token_recall (default)
+    2. llm_as_judge
+    3. granite_guardian
+    4. answer_relevance_model
+
+    Examples:
+        1. Create Answer Relevance metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = AnswerRelevanceMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "generated_text": "..."},
+                                                    metrics=[metric])
+
+        2. Create Answer Relevance metric with a custom thresholds and method.
+            .. code-block:: python
+
+                thresholds  = [MetricThreshold(type="lower_limit", value=0.5)]
+                method = "token_recall"
+                metric = AnswerRelevanceMetric(
+                    method=method, thresholds=thresholds)
+
+        3. Create Answer Relevance metric with llm_as_judge method.
+            .. code-block:: python
+
+                # Define LLM Judge using watsonx.ai
+                # To use other frameworks and models as llm_judge, see :module:`ibm_watsonx_gov.entities.foundation_model`
+                llm_judge = LLMJudge(model=WxAIFoundationModel(
+                                            model_id="ibm/granite-3-3-8b-instruct",
+                                            project_id="<PROJECT_ID>"))
+                metric = AnswerRelevanceMetric(llm_judge=llm_judge)
+
+        4. Create Answer Relevance metric with granite_guardian method.
+            .. code-block:: python
+
+                metric = AnswerRelevanceMetric(method="granite_guardian")
+
+        5. Create Answer Relevance metric with answer_relevance_model method. Currently available only in On-Prem version.
+            .. code-block:: python
+
+                metric = AnswerRelevanceMetric(method="answer_relevance_model")
+
+    """
+    name: Annotated[Literal["answer_relevance"],
+                    Field(title="Name",
+                          description="The answer relevance metric name.",
+                          default=ANSWER_RELEVANCE, frozen=True)]
+    display_name: Annotated[Literal["Answer Relevance"],
+                            Field(title="Display Name",
+                                  description="The answer relevance metric display name.",
+                                  default="Answer Relevance", frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=[TaskType.RAG, TaskType.QA])]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="lower_limit", value=0.7)])]
+    method: Annotated[Literal["token_recall", "llm_as_judge", "granite_guardian", "answer_relevance_model"],
+                      Field(title="Method",
+                            description="The method used to compute the metric. This field is optional and when `llm_judge` is provided, the method would be set to `llm_as_judge`.The `answer_relevance_model` method is currently available only in On-Prem version.",
+                            default="token_recall")]
+    group: Annotated[MetricGroup,
+                     Field(title="Group",
+                           description="The metric group.",
+                           default=MetricGroup.ANSWER_QUALITY, frozen=True)]
+    llm_judge: Annotated[LLMJudge | None,
+                         Field(title="LLM Judge",
+                               description="The LLM judge used to compute the metric.",
+                               default=None)]
+
+    @model_validator(mode="after")
+    def set_llm_judge_default_method(self) -> Self:
+        # If llm_judge is set, set the method to llm_as_judge
+        if self.llm_judge:
+            self.method = "llm_as_judge"
+        return self
+
+    def evaluate(self,
+                 data: pd.DataFrame,
+                 configuration: GenAIConfiguration | AgenticAIConfiguration,
+                 **kwargs) -> AggregateMetricResult:
+        # If ran in sync mode, block until it is done
+        return run_in_event_loop(
+            self.evaluate_async,
+            data=data,
+            configuration=configuration,
+            **kwargs,
+        )
+
+    def __is_supported(self, **kwargs):
+        # Currently supported only in CPD and ypqa
+        return kwargs.get(
+            "api_client").credentials.region == "ypqa" or kwargs.get("api_client").is_cpd
+
+    async def evaluate_async(self, data: pd.DataFrame,
+                             configuration: GenAIConfiguration | AgenticAIConfiguration,
+                             **kwargs) -> AggregateMetricResult:
+
+        data_cols = data.columns.to_list()
+        try:
+            validate_input(data_cols, configuration)
+            validate_output(data_cols, configuration)
+            validate_unitxt_method(self.name, self.method, unitxt_methods)
+            validate_llm_as_judge(self.name, self.method,
+                                  self.llm_judge, configuration.llm_judge)
+            validate_small_model_method(
+                self.name, self.method, self.__is_supported(**kwargs), unitxt_methods)
+        except ValueError as ve:
+            if kwargs.get("ignore_validation_errors"):
+                message = f"Skipping '{self.name}' computation because the validation failed. Details: {str(ve)}"
+                logger.warning(message)
+                return
+            raise ve
+
+        # Separate the data into a dataframe with no None values and a dataframe with None values
+        required_fields = configuration.input_fields + configuration.output_fields
+        mask_has_none = data[required_fields].isna().any(axis=1)
+        df_with_none = data[mask_has_none]
+        df_without_none = data[mask_has_none == False]
+
+        # Compute the metrics only for the dataframe with no None values
+        aggregated_metric_result = None
+        if not df_without_none.empty:
+            # Define the mapping if the method is not using the default one
+            if self.method == "token_recall":
+                column_mapping = UnitxtColumnMapping(
+                    answer="prediction/answer",
+                    question="task_data/question",
+                )
+            else:
+                column_mapping = UnitxtColumnMapping()
+            if self.method in ["granite_guardian", "answer_relevance_model"]:
+                kwargs["detector_params"] = {
+                    "method": self.method, "threshold": 0.001}
+                provider = DetectorsProvider(configuration=configuration,
+                                             metric_name=self.name,
+                                             metric_display_name=self.display_name,
+                                             metric_method=self.method,
+                                             metric_group=MetricGroup.ANSWER_QUALITY,
+                                             thresholds=self.thresholds,
+                                             **kwargs)
+            else:
+                provider = UnitxtProvider(
+                    configuration=configuration,
+                    metric_name=self.name,
+                    metric_display_name=self.display_name,
+                    metric_method=self.method,
+                    metric_prefix="metrics.rag.external_rag",
+                    metric_alias=UNITXT_METRIC_NAME,
+                    metric_group=self.group,
+                    column_mapping=column_mapping,
+                    llm_judge=self.llm_judge,
+                    thresholds=self.thresholds,
+                    **kwargs,
+                )
+
+            aggregated_metric_result = await provider.evaluate_async(data=df_without_none)
+
+        # Update the metric result with record level metrics results for the records with missing values
+        if not df_with_none.empty:
+            # Create None results for records with missing values
+            none_results = []
+            for _, row in df_with_none.iterrows():
+                record_result = RecordMetricResult(
+                    name=self.name,
+                    display_name=self.display_name,
+                    method=self.method,
+                    group=self.group,
+                    value=None,
+                    record_id=row[configuration.record_id_field],
+                    thresholds=self.thresholds,
+                    errors=[Error(
+                        code="BAD_REQUEST", message_en="The value of required fields input or output is None.")]
+                )
+                none_results.append(record_result)
+
+            # Merge the results
+            if aggregated_metric_result:
+                all_record_results = aggregated_metric_result.record_level_metrics + none_results
+                aggregated_metric_result.record_level_metrics = all_record_results
+                aggregated_metric_result.total_records = len(
+                    all_record_results)
+            else:
+                aggregated_metric_result = AggregateMetricResult(
+                    name=self.name,
+                    display_name=self.display_name,
+                    method=self.method,
+                    group=self.group,
+                    value=None,
+                    total_records=len(none_results),
+                    record_level_metrics=none_results,
+                    min=None,
+                    max=None,
+                    mean=None,
+                    thresholds=self.thresholds
+                )
+
+        return aggregated_metric_result

ibm_watsonx_gov/metrics/answer_similarity/answer_similarity_decorator.py

@@ -0,0 +1,66 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.answer_similarity.answer_similarity_metric import \
+    AnswerSimilarityMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+
+
+class AnswerSimilarityDecorator(BaseMetricDecorator):
+    def evaluate_answer_similarity(self,
+                                   func: Optional[Callable] = None,
+                                   *,
+                                   configuration: Optional[AgenticAIConfiguration] = None,
+                                   metrics: list[GenAIMetric] = []
+                                   ) -> dict:
+        """
+        An evaluation decorator for computing answer similarity metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_answer_similarity, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [AnswerSimilarityMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(AnswerSimilarityMetric,))
+
+                metric_inputs = [
+                    EvaluatorFields.INPUT_FIELDS,
+                    EvaluatorFields.CONTEXT_FIELDS
+                ]
+                metric_references = [EvaluatorFields.REFERENCE_FIELDS]
+                metric_outputs = [EvaluatorFields.OUTPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=metric_outputs,
+                                                      metric_references=metric_references)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating answer similarity metric on {func.__name__},") from ex
+
+        return wrapper(func)