rasa-pro 3.12.0.dev1__py3-none-any.whl

rasa/core/nlg/contextual_response_rephraser.py

@@ -0,0 +1,320 @@
+from typing import Any, Dict, Optional, Text
+
+import structlog
+from jinja2 import Template
+from rasa import telemetry
+from rasa.core.nlg.response import TemplatedNaturalLanguageGenerator
+from rasa.core.nlg.summarize import summarize_conversation
+from rasa.shared.constants import (
+    LLM_CONFIG_KEY,
+    MODEL_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
+    PROMPT_CONFIG_KEY,
+    PROVIDER_CONFIG_KEY,
+    OPENAI_PROVIDER,
+    TIMEOUT_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+)
+from rasa.shared.core.domain import KEY_RESPONSES_TEXT, Domain
+from rasa.shared.core.events import BotUttered, UserUttered
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
+from rasa.shared.utils.llm import (
+    DEFAULT_OPENAI_GENERATE_MODEL_NAME,
+    DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    USER,
+    combine_custom_and_default_config,
+    get_prompt_template,
+    llm_factory,
+    resolve_model_client_config,
+)
+from rasa.shared.utils.llm import (
+    tracker_as_readable_transcript,
+)
+from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.log_utils import log_llm
+
+structlogger = structlog.get_logger()
+
+RESPONSE_REPHRASING_KEY = "rephrase"
+
+RESPONSE_REPHRASING_TEMPLATE_KEY = "rephrase_prompt"
+
+RESPONSE_SUMMARISE_CONVERSATION_KEY = "summarize_conversation"
+
+DEFAULT_REPHRASE_ALL = False
+DEFAULT_SUMMARIZE_HISTORY = True
+DEFAULT_MAX_HISTORICAL_TURNS = 5
+
+DEFAULT_LLM_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    MODEL_CONFIG_KEY: DEFAULT_OPENAI_GENERATE_MODEL_NAME,
+    "temperature": 0.3,
+    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+    TIMEOUT_CONFIG_KEY: 5,
+}
+
+DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE = """The following is a conversation with
+an AI assistant. The assistant is helpful, creative, clever, and very friendly.
+Rephrase the suggested AI response staying close to the original message and retaining
+its meaning. Use simple english.
+
+Context / previous conversation with the user:
+{{history}}
+
+{{current_input}}
+
+Suggested AI Response: {{suggested_response}}
+
+Rephrased AI Response:"""
+
+
+class ContextualResponseRephraser(
+    LLMHealthCheckMixin, TemplatedNaturalLanguageGenerator
+):
+    """Generates responses based on modified templates.
+
+    The templates are filled with the entities and slots that are available in the
+    tracker. The resulting response is then passed through the LLM to generate a
+    variation of the response.
+
+    The variation is only generated if the response is a text response and the
+    response explicitly set `rephrase` to `True`. This is to avoid
+    generating responses for templates that are to volatile to be
+    modified by the LLM.
+
+    Args:
+        endpoint_config: The endpoint configuration for the LLM.
+        domain: The domain of the assistant.
+
+    Attributes:
+        nlg_endpoint: The endpoint configuration for the LLM.
+    """
+
+    def __init__(self, endpoint_config: EndpointConfig, domain: Domain) -> None:
+        super().__init__(domain.responses)
+
+        self.nlg_endpoint = endpoint_config
+        self.prompt_template = get_prompt_template(
+            self.nlg_endpoint.kwargs.get(PROMPT_CONFIG_KEY),
+            DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE,
+        )
+        self.rephrase_all = self.nlg_endpoint.kwargs.get(
+            "rephrase_all", DEFAULT_REPHRASE_ALL
+        )
+        self.trace_prompt_tokens = self.nlg_endpoint.kwargs.get(
+            "trace_prompt_tokens", False
+        )
+        self.summarize_history = self.nlg_endpoint.kwargs.get(
+            "summarize_history", DEFAULT_SUMMARIZE_HISTORY
+        )
+        self.max_historical_turns = self.nlg_endpoint.kwargs.get(
+            "max_historical_turns", DEFAULT_MAX_HISTORICAL_TURNS
+        )
+
+        self.llm_config = resolve_model_client_config(
+            self.nlg_endpoint.kwargs.get(LLM_CONFIG_KEY),
+            ContextualResponseRephraser.__name__,
+        )
+
+        self.perform_llm_health_check(
+            self.llm_config,
+            DEFAULT_LLM_CONFIG,
+            "contextual_response_rephraser.init",
+            ContextualResponseRephraser.__name__,
+        )
+
+    def _last_message_if_human(self, tracker: DialogueStateTracker) -> Optional[str]:
+        """Returns the latest message from the tracker.
+
+        If the latest message is from the AI, it returns None.
+
+        Args:
+            tracker: The tracker to get the latest message from.
+
+        Returns:
+            The latest message from the tracker if it is from the user, else None.
+        """
+        for event in reversed(tracker.events):
+            if isinstance(event, UserUttered):
+                return event.text
+            if isinstance(event, BotUttered):
+                return None
+        return None
+
+    async def _generate_llm_response(self, prompt: str) -> Optional[str]:
+        """Use LLM to generate a response.
+
+        Args:
+            prompt: the prompt to send to the LLM
+
+        Returns:
+            generated text
+        """
+        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+
+        try:
+            llm_response = await llm.acompletion(prompt)
+            return llm_response.choices[0]
+        except Exception as e:
+            # unfortunately, langchain does not wrap LLM exceptions which means
+            # we have to catch all exceptions here
+            structlogger.error("nlg.llm.error", error=e)
+            return None
+
+    def llm_property(self, prop: str) -> Optional[str]:
+        """Returns a property of the LLM provider."""
+        return combine_custom_and_default_config(
+            self.llm_config, DEFAULT_LLM_CONFIG
+        ).get(prop)
+
+    def custom_prompt_template(self, prompt_template: str) -> Optional[str]:
+        """Returns the custom prompt template if it is not the default one."""
+        if prompt_template != DEFAULT_RESPONSE_VARIATION_PROMPT_TEMPLATE:
+            return prompt_template
+        else:
+            return None
+
+    def _template_for_response_rephrasing(self, response: Dict[str, Any]) -> str:
+        """Returns the template for the response rephrasing.
+
+        Args:
+            response: The response to rephrase.
+
+        Returns:
+            The template for the response rephrasing.
+        """
+        return response.get("metadata", {}).get(
+            RESPONSE_REPHRASING_TEMPLATE_KEY, self.prompt_template
+        )
+
+    async def _create_history(self, tracker: DialogueStateTracker) -> str:
+        """Creates the history for the prompt.
+
+        Args:
+            tracker: The tracker to use for the history.
+
+
+        Returns:
+        The history for the prompt.
+        """
+        llm = llm_factory(self.llm_config, DEFAULT_LLM_CONFIG)
+        return await summarize_conversation(tracker, llm, max_turns=5)
+
+    async def rephrase(
+        self,
+        response: Dict[str, Any],
+        tracker: DialogueStateTracker,
+    ) -> Dict[str, Any]:
+        """Predicts a variation of the response.
+
+        Args:
+            response: The response to rephrase.
+            tracker: The tracker to use for the prediction.
+            model_name: The name of the model to use for the prediction.
+
+        Returns:
+            The response with the rephrased text.
+        """
+        if not (response_text := response.get(KEY_RESPONSES_TEXT)):
+            return response
+
+        prompt_template_text = self._template_for_response_rephrasing(response)
+
+        # Retrieve inputs for the dynamic prompt
+        latest_message = self._last_message_if_human(tracker)
+        current_input = f"{USER}: {latest_message}" if latest_message else ""
+
+        # Only summarise conversation history if flagged
+        if self.summarize_history:
+            history = await self._create_history(tracker)
+        else:
+            # make sure the transcript/history contains the last user utterance
+            max_turns = max(self.max_historical_turns, 1)
+            history = tracker_as_readable_transcript(tracker, max_turns=max_turns)
+            # the history already contains the current input
+            current_input = ""
+
+        prompt = Template(prompt_template_text).render(
+            history=history,
+            suggested_response=response_text,
+            current_input=current_input,
+            slots=tracker.current_slot_values(),
+        )
+        log_llm(
+            logger=structlogger,
+            log_module="ContextualResponseRephraser",
+            log_event="nlg.rephrase.prompt_rendered",
+            prompt=prompt,
+        )
+        telemetry.track_response_rephrase(
+            rephrase_all=self.rephrase_all,
+            custom_prompt_template=self.custom_prompt_template(prompt_template_text),
+            llm_type=self.llm_property(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_property(MODEL_CONFIG_KEY)
+            or self.llm_property(MODEL_NAME_CONFIG_KEY),
+            llm_model_group_id=self.llm_property(MODEL_GROUP_ID_CONFIG_KEY),
+        )
+        if not (updated_text := await self._generate_llm_response(prompt)):
+            # If the LLM fails to generate a response, we
+            # return the original response.
+            return response
+
+        structlogger.debug(
+            "nlg.rewrite.complete",
+            response_text=response_text,
+            updated_text=updated_text,
+        )
+        response[KEY_RESPONSES_TEXT] = updated_text
+        return response
+
+    def does_response_allow_rephrasing(self, template: Dict[Text, Any]) -> bool:
+        """Checks if the template allows variation.
+
+        Args:
+            template: The template to check.
+
+        Returns:
+            `True` if the template allows variation, else `False`.
+        """
+        return template.get("metadata", {}).get(
+            RESPONSE_REPHRASING_KEY, self.rephrase_all
+        )
+
+    async def generate(
+        self,
+        utter_action: Text,
+        tracker: DialogueStateTracker,
+        output_channel: Text,
+        **kwargs: Any,
+    ) -> Optional[Dict[Text, Any]]:
+        """Generate a response for the requested utter action.
+
+        Args:
+            utter_action: The name of the utter action to generate a response for.
+            tracker: The tracker to use for the generation.
+            output_channel: The output channel to use for the generation.
+            **kwargs: Additional arguments to pass to the generation.
+
+        Returns:
+            The generated response.
+        """
+        filled_slots = tracker.current_slot_values()
+        stack_context = tracker.stack.current_context()
+        templated_response = self.generate_from_slots(
+            utter_action=utter_action,
+            filled_slots=filled_slots,
+            stack_context=stack_context,
+            output_channel=output_channel,
+            **kwargs,
+        )
+
+        if templated_response and self.does_response_allow_rephrasing(
+            templated_response
+        ):
+            return await self.rephrase(
+                templated_response,
+                tracker,
+            )
+        else:
+            return templated_response

rasa/core/nlg/generator.py

@@ -0,0 +1,230 @@
+import logging
+from typing import List, Optional, Union, Text, Any, Dict
+
+import rasa.shared.utils.common
+import rasa.shared.utils.io
+from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
+from rasa.shared.core.domain import Domain
+from rasa.utils.endpoints import EndpointConfig
+from rasa.shared.core.trackers import DialogueStateTracker
+
+logger = logging.getLogger(__name__)
+
+
+class NaturalLanguageGenerator:
+    """Generate bot utterances based on a dialogue state."""
+
+    async def generate(
+        self,
+        utter_action: Text,
+        tracker: "DialogueStateTracker",
+        output_channel: Text,
+        **kwargs: Any,
+    ) -> Optional[Dict[Text, Any]]:
+        """Generate a response for the requested utter action.
+
+        There are a lot of different methods to implement this, e.g. the
+        generation can be based on responses or be fully ML based by feeding
+        the dialogue state into a machine learning NLG model.
+        """
+        raise NotImplementedError
+
+    @staticmethod
+    def create(
+        obj: Union["NaturalLanguageGenerator", EndpointConfig, None],
+        domain: Optional[Domain] = None,
+    ) -> "NaturalLanguageGenerator":
+        """Factory to create a generator."""
+        if isinstance(obj, NaturalLanguageGenerator):
+            return obj
+        else:
+            return _create_from_endpoint_config(obj, domain)
+
+
+def _create_from_endpoint_config(
+    endpoint_config: Optional[EndpointConfig] = None, domain: Optional[Domain] = None
+) -> "NaturalLanguageGenerator":
+    """Given an endpoint configuration, create a proper NLG object."""
+    domain = domain or Domain.empty()
+
+    if endpoint_config is None:
+        from rasa.core.nlg import TemplatedNaturalLanguageGenerator
+
+        # this is the default type if no endpoint config is set
+        nlg: "NaturalLanguageGenerator" = TemplatedNaturalLanguageGenerator(
+            domain.responses
+        )
+    elif endpoint_config.type is None or endpoint_config.type.lower() == "callback":
+        from rasa.core.nlg import CallbackNaturalLanguageGenerator
+
+        # this is the default type if no nlg type is set
+        nlg = CallbackNaturalLanguageGenerator(endpoint_config=endpoint_config)
+    elif endpoint_config.type.lower() == "response":
+        from rasa.core.nlg import TemplatedNaturalLanguageGenerator
+
+        nlg = TemplatedNaturalLanguageGenerator(domain.responses)
+    elif endpoint_config.type.lower() == "rephrase":
+        from rasa.core.nlg.contextual_response_rephraser import (
+            ContextualResponseRephraser,
+        )
+
+        nlg = ContextualResponseRephraser(
+            endpoint_config=endpoint_config, domain=domain
+        )
+    else:
+        nlg = _load_from_module_name_in_endpoint_config(endpoint_config, domain)
+
+    logger.debug(f"Instantiated NLG to '{nlg.__class__.__name__}'.")
+    return nlg
+
+
+def _load_from_module_name_in_endpoint_config(
+    endpoint_config: EndpointConfig, domain: Domain
+) -> "NaturalLanguageGenerator":
+    """Initializes a custom natural language generator.
+
+    Args:
+        domain: defines the universe in which the assistant operates
+        endpoint_config: the specific natural language generator
+    """
+    try:
+        nlg_class = rasa.shared.utils.common.class_from_module_path(
+            endpoint_config.type
+        )
+        return nlg_class(endpoint_config=endpoint_config, domain=domain)
+    except (AttributeError, ImportError) as e:
+        raise Exception(
+            f"Could not find a class based on the module path "
+            f"'{endpoint_config.type}'. Failed to create a "
+            f"`NaturalLanguageGenerator` instance. Error: {e}"
+        )
+
+
+class ResponseVariationFilter:
+    """Filters response variations based on the channel, action and condition."""
+
+    def __init__(self, responses: Dict[Text, List[Dict[Text, Any]]]) -> None:
+        self.responses = responses
+
+    @staticmethod
+    def _matches_filled_slots(
+        filled_slots: Dict[Text, Any], response: Dict[Text, Any]
+    ) -> bool:
+        """Checks if the conditional response variation matches the filled slots."""
+        constraints = response.get(RESPONSE_CONDITION, [])
+        for constraint in constraints:
+            name = constraint["name"]
+            value = constraint["value"]
+            filled_slots_value = filled_slots.get(name)
+            if isinstance(filled_slots_value, str) and isinstance(value, str):
+                if filled_slots_value.casefold() != value.casefold():
+                    return False
+            # slot values can be of different data types
+            # such as int, float, bool, etc. hence, this check
+            # executes when slot values are not strings
+            elif filled_slots_value != value:
+                return False
+
+        return True
+
+    def responses_for_utter_action(
+        self,
+        utter_action: Text,
+        output_channel: Text,
+        filled_slots: Dict[Text, Any],
+    ) -> List[Dict[Text, Any]]:
+        """Returns array of responses that fit the channel, action and condition."""
+        # filter responses without a condition
+        default_responses = list(
+            filter(
+                lambda x: (x.get(RESPONSE_CONDITION) is None),
+                self.responses[utter_action],
+            )
+        )
+        # filter responses with a condition that matches the filled slots
+        conditional_responses = list(
+            filter(
+                lambda x: (
+                    x.get(RESPONSE_CONDITION)
+                    and self._matches_filled_slots(
+                        filled_slots=filled_slots, response=x
+                    )
+                ),
+                self.responses[utter_action],
+            )
+        )
+
+        # filter conditional responses that match the channel
+        conditional_channel = list(
+            filter(lambda x: (x.get(CHANNEL) == output_channel), conditional_responses)
+        )
+        # filter conditional responses that don't match the channel
+        conditional_no_channel = list(
+            filter(lambda x: (x.get(CHANNEL) is None), conditional_responses)
+        )
+        # filter default responses that match the channel
+        default_channel = list(
+            filter(lambda x: (x.get(CHANNEL) == output_channel), default_responses)
+        )
+        # filter default responses that don't match the channel
+        default_no_channel = list(
+            filter(lambda x: (x.get(CHANNEL) is None), default_responses)
+        )
+
+        if conditional_channel:
+            return conditional_channel
+
+        if default_channel:
+            return default_channel
+
+        if conditional_no_channel:
+            return conditional_no_channel
+
+        return default_no_channel
+
+    def get_response_variation_id(
+        self,
+        utter_action: Text,
+        tracker: DialogueStateTracker,
+        output_channel: Text,
+    ) -> Optional[Text]:
+        """Returns the first matched response variation ID.
+
+        This ID corresponds to the response variation that fits
+        the channel, action and condition.
+        """
+        filled_slots = tracker.current_slot_values()
+        if utter_action in self.responses:
+            eligible_variations = self.responses_for_utter_action(
+                utter_action, output_channel, filled_slots
+            )
+            response_ids_are_valid = self._validate_response_ids(eligible_variations)
+
+            if eligible_variations and response_ids_are_valid:
+                return eligible_variations[0].get("id")
+
+        return None
+
+    @staticmethod
+    def _validate_response_ids(response_variations: List[Dict[Text, Any]]) -> bool:
+        """Checks that the response IDs of a particular utter_action are unique.
+
+        Args:
+            response_variations: The response variations to validate.
+
+        Returns:
+            True if the response IDs are unique, False otherwise.
+        """
+        response_ids = set()
+        for response_variation in response_variations:
+            response_variation_id = response_variation.get("id")
+            if response_variation_id and response_variation_id in response_ids:
+                rasa.shared.utils.io.raise_warning(
+                    f"Duplicate response id '{response_variation_id}' "
+                    f"defined in the domain."
+                )
+                return False
+
+            response_ids.add(response_variation_id)
+
+        return True

rasa/core/nlg/interpolator.py

@@ -0,0 +1,143 @@
+import copy
+import re
+import logging
+from jinja2 import Template
+import jinja2
+import structlog
+from typing import Text, Dict, Union, Any, List
+
+from rasa.core.constants import JINJA2_TEMPLATE_ENGINE, RASA_FORMAT_TEMPLATE_ENGINE
+
+logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
+
+
+def _get_variables_to_be_rendered(
+    response: Text, values: Dict[Text, Text]
+) -> Dict[Text, Text]:
+    """Get the variables that need to be rendered in the response.
+
+    Args:
+        response: The response that should be interpolated.
+        values: A dictionary of keys and the values that those
+            keys should be replaced with.
+
+    Returns:
+        The variables that need to be rendered.
+    """
+    # The regex matches and captures all the strings that are enclosed in curly braces.
+    # The strings should not contain newlines or curly braces.
+    variables = re.findall(r"{([^\n{}]+?)}", response)
+    return {var: values[var] for var in variables if var in values}
+
+
+def interpolate_format_template(response: Text, values: Dict[Text, Text]) -> Text:
+    """Interpolate values into responses with placeholders.
+
+    Transform response tags from "{tag_name}" to "{0[tag_name]}" as described here:
+    https://stackoverflow.com/questions/7934620/python-dots-in-the-name-of-variable-in-a-format-string#comment9695339_7934969
+    Block characters, making sure not to allow:
+    (a) newline in slot name
+    (b) { or } in slot name
+
+    Args:
+        response: The piece of text that should be interpolated.
+        values: A dictionary of keys and the values that those
+            keys should be replaced with.
+
+    Returns:
+        The piece of text with any replacements made.
+    """
+    try:
+        values_to_be_rendered = _get_variables_to_be_rendered(response, values)
+        text = re.sub(r"{([^\n{}]+?)}", r"{0[\1]}", response)
+        text = text.format(values_to_be_rendered)
+        if "0[" in text:
+            # regex replaced tag but format did not replace
+            # likely cause would be that tag name was enclosed
+            # in double curly and format func simply escaped it.
+            # we don't want to return {0[SLOTNAME]} thus
+            # restoring original value with { being escaped.
+            return response.format({})
+
+        return text
+    except KeyError as e:
+        event_info = (
+            "The specified slot name does not exist, "
+            "and no explicit value was provided during the response invocation. "
+            "Return the response without populating it."
+        )
+        structlogger.exception(
+            "interpolator.interpolate.text",
+            response=copy.deepcopy(response),
+            placeholder_key=e.args[0],
+            event_info=event_info,
+        )
+        return response
+
+
+def interpolate_jinja_template(response: Text, values: Dict[Text, Any]) -> Text:
+    """Interpolate values into responses with placeholders using jinja.
+
+    Args:
+        response: The piece of text that should be interpolated.
+        values: A dictionary of keys and the values that those
+            keys should be replaced with.
+
+    Returns:
+    The piece of text with any replacements made.
+    """
+    try:
+        return Template(response).render(values)
+    except jinja2.exceptions.UndefinedError as e:
+        event_info = (
+            "The specified slot name does not exist, "
+            "and no explicit value was provided during the response invocation. "
+            "Return the response without populating it."
+        )
+        structlogger.exception(
+            "interpolator.interpolate.text",
+            response=copy.deepcopy(response),
+            placeholder_key=e.args[0],
+            event_info=event_info,
+        )
+        return response
+
+
+def interpolate(
+    response: Union[List[Any], Dict[Text, Any], Text],
+    values: Dict[Text, Text],
+    method: str,
+) -> Union[List[Any], Dict[Text, Any], Text]:
+    """Recursively process response and interpolate any text keys.
+
+    Args:
+        response: The response that should be interpolated.
+        values: A dictionary of keys and the values that those
+            keys should be replaced with.
+        method: The method to use for interpolation. If `None` or `"format"`,
+
+    Returns:
+        The response with any replacements made.
+    """
+    if method == RASA_FORMAT_TEMPLATE_ENGINE:
+        interpolator = interpolate_format_template
+    elif method == JINJA2_TEMPLATE_ENGINE:
+        interpolator = interpolate_jinja_template
+    else:
+        raise ValueError(f"Unknown interpolator implementation '{method}'")
+
+    if isinstance(response, str):
+        return interpolator(response, values)
+    elif isinstance(response, dict):
+        for k, v in response.items():
+            if isinstance(v, dict):
+                interpolate(v, values, method)
+            elif isinstance(v, list):
+                response[k] = [interpolate(i, values, method) for i in v]
+            elif isinstance(v, str):
+                response[k] = interpolator(v, values)
+        return response
+    elif isinstance(response, list):
+        return [interpolate(i, values, method) for i in response]
+    return response