rasa-pro 3.8.18__py3-none-any.whl → 3.9.15__py3-none-any.whl

rasa/dialogue_understanding/generator/command_generator.py

@@ -3,8 +3,17 @@ from typing import Any, Dict, List, Optional, Text
 
 import structlog
 
-from rasa.dialogue_understanding.commands import Command, StartFlowCommand, ErrorCommand
+from rasa.dialogue_understanding.commands import (
+    Command,
+    SetSlotCommand,
+    StartFlowCommand,
+    ErrorCommand,
+)
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.shared.core.constants import SlotMappingType
+from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.constants import COMMANDS, TEXT
@@ -53,6 +62,7 @@ class CommandGenerator:
         messages: List[Message],
         flows: FlowsList,
         tracker: Optional[DialogueStateTracker] = None,
+        domain: Optional[Domain] = None,
     ) -> List[Message]:
         """Process a list of messages. For each message predict commands.
 
@@ -63,6 +73,7 @@ class CommandGenerator:
             messages: The messages to process.
             tracker: The tracker containing the conversation history up to now.
             flows: The flows to use for command prediction.
+            domain: The domain.
 
         Returns:
         The processed messages (usually this is just one during prediction).
@@ -78,14 +89,13 @@ class CommandGenerator:
         )
 
         for message in messages:
-
             if message.get(COMMANDS):
                 # do not overwrite commands if they are already present
                 # i.e. another command generator already predicted commands
                 continue
 
             commands = await self._evaluate_and_predict(
-                message, available_flows, tracker
+                message, available_flows, tracker, domain
             )
             # Double check commands for guarded flows. Unlikely but the llm could
             # have predicted a command for a flow that is not in the startable
@@ -93,6 +103,9 @@ class CommandGenerator:
             commands = self._check_commands_against_startable_flows(
                 commands, startable_flows
             )
+            commands = self._check_commands_against_slot_mappings(
+                commands, tracker, domain
+            )
             commands_dicts = [command.as_dict() for command in commands]
             message.set(COMMANDS, commands_dicts, add_to_output=True)
 
@@ -139,6 +152,7 @@ class CommandGenerator:
         message: Message,
         startable_flows: FlowsList,
         tracker: Optional[DialogueStateTracker] = None,
+        domain: Optional[Domain] = None,
     ) -> List[Command]:
         """Evaluates message for errors and predicts commands if no errors are found.
 
@@ -156,7 +170,9 @@ class CommandGenerator:
 
         # if no errors, try predicting commands
         try:
-            return await self.predict_commands(message, startable_flows, tracker)
+            return await self.predict_commands(
+                message, startable_flows, tracker, domain=domain
+            )
         except NotImplementedError:
             raise
         except Exception as e:
@@ -168,6 +184,7 @@ class CommandGenerator:
         message: Message,
         flows: FlowsList,
         tracker: Optional[DialogueStateTracker] = None,
+        **kwargs: Any,
     ) -> List[Command]:
         """Predict commands for a single message.
 
@@ -175,7 +192,7 @@ class CommandGenerator:
             message: The message to predict commands for.
             flows: The flows to use for command prediction.
             tracker: The tracker containing the conversation history up to now.
-
+            **kwargs: Keyword arguments for forward compatibility.
         Returns:
         The predicted commands.
         """
@@ -188,7 +205,7 @@ class CommandGenerator:
 
         Args:
             commands: The commands to check.
-            startable_flows: The flows which have their starting conditions statisfied.
+            startable_flows: The flows which have their starting conditions satisfied.
 
         Returns:
             The commands that are startable.
@@ -255,3 +272,72 @@ class CommandGenerator:
     def check_if_message_is_empty(self, message: Message) -> bool:
         """Checks if the given message is empty or whitespace-only."""
         return len(message.get(TEXT, "").strip()) == 0
+
+    @staticmethod
+    def _check_commands_against_slot_mappings(
+        commands: List[Command],
+        tracker: DialogueStateTracker,
+        domain: Optional[Domain] = None,
+    ) -> List[Command]:
+        """Check if the LLM-issued slot commands are fillable.
+
+        The LLM-issued slot commands are fillable if the slot
+        mappings are satisfied.
+        """
+        if not domain:
+            return commands
+
+        llm_fillable_slot_names = [
+            command.name
+            for command in commands
+            if isinstance(command, SetSlotCommand)
+            and command.extractor == SetSlotExtractor.LLM.value
+        ]
+
+        if not llm_fillable_slot_names:
+            return commands
+
+        llm_fillable_slots = [
+            slot for slot in domain.slots if slot.name in llm_fillable_slot_names
+        ]
+
+        slot_filling_manager = SlotFillingManager(domain, tracker)
+        slots_to_be_removed = []
+
+        structlogger.debug(
+            "command_processor.check_commands_against_slot_mappings.active_flow",
+            active_flow=tracker.active_flow,
+        )
+
+        for slot in llm_fillable_slots:
+            should_fill_slot = False
+            for mapping in slot.mappings:
+                mapping_type = SlotMappingType(mapping.get("type"))
+
+                should_fill_slot = slot_filling_manager.should_fill_slot(
+                    slot.name, mapping_type, mapping
+                )
+
+                if should_fill_slot:
+                    break
+
+            if not should_fill_slot:
+                structlogger.debug(
+                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
+                    slot_name=slot.name,
+                )
+                slots_to_be_removed.append(slot.name)
+
+        if not slots_to_be_removed:
+            return commands
+
+        filtered_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, SetSlotCommand)
+                and command.name in slots_to_be_removed
+            )
+        ]
+
+        return filtered_commands

rasa/dialogue_understanding/generator/constants.py

@@ -0,0 +1,18 @@
+from rasa.shared.utils.llm import (
+    DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
+    DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+)
+
+DEFAULT_LLM_CONFIG = {
+    "_type": "openai",
+    "request_timeout": 7,
+    "temperature": 0.0,
+    "model_name": DEFAULT_OPENAI_CHAT_MODEL_NAME_ADVANCED,
+    "max_tokens": DEFAULT_OPENAI_MAX_GENERATED_TOKENS,
+}
+
+LLM_CONFIG_KEY = "llm"
+USER_INPUT_CONFIG_KEY = "user_input"
+
+FLOW_RETRIEVAL_KEY = "flow_retrieval"
+FLOW_RETRIEVAL_ACTIVE_KEY = "active"

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -34,6 +34,7 @@ from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import TEXT, FLOWS_FROM_SEMANTIC_SEARCH
 from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.exceptions import ProviderClientAPIException
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     embedder_factory,
@@ -93,11 +94,10 @@ class FlowRetrieval:
 
     @classmethod
     def validate_config(cls, config: Dict[Text, Any]) -> Dict[Text, Any]:
-
         if config[MAX_FLOWS_FROM_SEMANTIC_SEARCH_KEY] < 0:
-            config[
-                MAX_FLOWS_FROM_SEMANTIC_SEARCH_KEY
-            ] = DEFAULT_MAX_FLOWS_FROM_SEMANTIC_SEARCH
+            config[MAX_FLOWS_FROM_SEMANTIC_SEARCH_KEY] = (
+                DEFAULT_MAX_FLOWS_FROM_SEMANTIC_SEARCH
+            )
             structlogger.error(
                 f"flow_retrieval.validate_config.{MAX_FLOWS_FROM_SEMANTIC_SEARCH_KEY}.set_as_negative",
                 event_info=(
@@ -407,4 +407,6 @@ class FlowRetrieval:
                 error=e,
                 query=query,
             )
-            raise
+            raise ProviderClientAPIException(
+                message="Cannot fetch flows from vector store", original_exception=e
+            )

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -0,0 +1,467 @@
+from abc import ABC, abstractmethod
+from functools import lru_cache
+from typing import Dict, Any, List, Optional, Tuple, Union, Text
+
+import structlog
+from jinja2 import Template
+
+import rasa.shared.utils.io
+from rasa.dialogue_understanding.commands import (
+    Command,
+    StartFlowCommand,
+)
+from rasa.dialogue_understanding.generator import CommandGenerator
+from rasa.dialogue_understanding.generator.constants import (
+    DEFAULT_LLM_CONFIG,
+    LLM_CONFIG_KEY,
+    FLOW_RETRIEVAL_KEY,
+    FLOW_RETRIEVAL_ACTIVE_KEY,
+)
+from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
+from rasa.engine.graph import GraphComponent, ExecutionContext
+from rasa.engine.recipes.default_recipe import DefaultV1Recipe
+from rasa.engine.storage.resource import Resource
+from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.flows import FlowStep, Flow, FlowsList
+from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import FileIOException
+from rasa.shared.exceptions import ProviderClientAPIException
+from rasa.shared.nlu.constants import FLOWS_IN_PROMPT
+from rasa.shared.nlu.training_data.message import Message
+from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.llm import (
+    llm_factory,
+    allowed_values_for_slot,
+)
+from rasa.utils.log_utils import log_llm
+
+structlogger = structlog.get_logger()
+
+
+@DefaultV1Recipe.register(
+    [
+        DefaultV1Recipe.ComponentType.COMMAND_GENERATOR,
+    ],
+    is_trainable=True,
+)
+class LLMBasedCommandGenerator(GraphComponent, CommandGenerator, ABC):
+    """An abstract class defining interface and common functionality
+    of an LLM-based command generators.
+    """
+
+    def __init__(
+        self,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(config)
+        self.config = {**self.get_default_config(), **config}
+        self._model_storage = model_storage
+        self._resource = resource
+        self.flow_retrieval: Optional[FlowRetrieval]
+
+        if self.enabled_flow_retrieval:
+            self.flow_retrieval = FlowRetrieval(
+                self.config[FLOW_RETRIEVAL_KEY], model_storage, resource
+            )
+            structlogger.info("llm_based_command_generator.flow_retrieval.enabled")
+        else:
+            self.flow_retrieval = None
+            structlogger.warn(
+                "llm_based_command_generator.flow_retrieval.disabled",
+                event_info=(
+                    "Disabling flow retrieval can cause issues when there are a "
+                    "large number of flows to be included in the prompt. For more"
+                    "information see:\n"
+                    "https://rasa.com/docs/rasa-pro/concepts/dialogue-understanding#how-the-llmcommandgenerator-works"
+                ),
+            )
+
+    ### Abstract methods
+    @staticmethod
+    @abstractmethod
+    def get_default_config() -> Dict[str, Any]:
+        """The component's default config."""
+        pass
+
+    @classmethod
+    @abstractmethod
+    def load(
+        cls: Any,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        **kwargs: Any,
+    ) -> "LLMBasedCommandGenerator":
+        """Loads trained component (see parent class for full docstring)."""
+        pass
+
+    @abstractmethod
+    def persist(self) -> None:
+        """Persist the component to disk for future loading."""
+        pass
+
+    @abstractmethod
+    async def predict_commands(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+        **kwargs: Any,
+    ) -> List[Command]:
+        """Predict commands using the LLM.
+
+        Args:
+            message: The message from the user.
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+            **kwargs: Keyword arguments for forward compatibility.
+
+        Returns:
+            The commands generated by the llm.
+        """
+        pass
+
+    @abstractmethod
+    def parse_commands(
+        cls, actions: Optional[str], tracker: DialogueStateTracker, flows: FlowsList
+    ) -> List[Command]:
+        """Parse the actions returned by the llm into intent and entities.
+
+        Args:
+            actions: The actions returned by the llm.
+            tracker: The tracker containing the current state of the conversation.
+            flows: the list of flows
+
+        Returns:
+            The parsed commands.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
+        """Add a fingerprint of the knowledge base for the graph."""
+        pass
+
+    ### Shared implementations of GraphComponent parent
+    @classmethod
+    def create(
+        cls,
+        config: Dict[str, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+    ) -> "LLMBasedCommandGenerator":
+        """Creates a new untrained component (see parent class for full docstring)."""
+        return cls(config, model_storage, resource)
+
+    def train(
+        self, training_data: TrainingData, flows: FlowsList, domain: Domain
+    ) -> Resource:
+        """Train the llm based command generator. Stores all flows into a vector
+        store.
+        """
+        # flow retrieval is populated with only user-defined flows
+        try:
+            if self.flow_retrieval is not None and not flows.is_empty():
+                self.flow_retrieval.populate(flows.user_flows, domain)
+        except Exception as e:
+            structlogger.error(
+                "llm_based_command_generator.train.failed",
+                event_info=("Flow retrieval store isinaccessible."),
+                error=e,
+            )
+            raise
+        self.persist()
+        return self._resource
+
+    ### Helper methods
+    @property
+    def enabled_flow_retrieval(self) -> bool:
+        return self.config[FLOW_RETRIEVAL_KEY].get(FLOW_RETRIEVAL_ACTIVE_KEY, True)
+
+    @lru_cache
+    def compile_template(self, template: str) -> Template:
+        """Compile the prompt template.
+
+        Compiling the template is an expensive operation,
+        so we cache the result.
+        """
+        return Template(template)
+
+    @classmethod
+    def load_prompt_template_from_model_storage(
+        cls,
+        model_storage: ModelStorage,
+        resource: Resource,
+        prompt_template_file_name: str,
+    ) -> Optional[Text]:
+        try:
+            with model_storage.read_from(resource) as path:
+                return rasa.shared.utils.io.read_file(path / prompt_template_file_name)
+        except (FileNotFoundError, FileIOException) as e:
+            structlogger.warning(
+                "llm_based_command_generator.load_prompt_template.failed",
+                error=e,
+                resource=resource.name,
+            )
+        return None
+
+    @classmethod
+    def load_flow_retrival(
+        cls, config: Dict[Text, Any], model_storage: ModelStorage, resource: Resource
+    ) -> Optional[FlowRetrieval]:
+        """Load the FlowRetrieval component if it is enabled in the configuration."""
+        enable_flow_retrieval = config.get(FLOW_RETRIEVAL_KEY, {}).get(
+            FLOW_RETRIEVAL_ACTIVE_KEY, True
+        )
+        if enable_flow_retrieval:
+            return FlowRetrieval.load(
+                config=config.get(FLOW_RETRIEVAL_KEY),
+                model_storage=model_storage,
+                resource=resource,
+            )
+        return None
+
+    async def filter_flows(
+        self,
+        message: Message,
+        flows: FlowsList,
+        tracker: Optional[DialogueStateTracker] = None,
+    ) -> FlowsList:
+        """Filters the available flows.
+
+        Args:
+            message: The message from the user.
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            Filtered list of flows.
+        """
+        # If the flow retrieval is disabled, use the all the provided flows.
+        filtered_flows = (
+            await self.flow_retrieval.filter_flows(tracker, message, flows)
+            if self.flow_retrieval is not None
+            else flows
+        )
+        # Filter flows based on current context (tracker and message)
+        # to identify which flows LLM can potentially start.
+        if tracker:
+            filtered_flows = tracker.get_startable_flows(filtered_flows)
+        else:
+            filtered_flows = filtered_flows
+
+        # add the filtered flows to the message for evaluation purposes
+        message.set(
+            FLOWS_IN_PROMPT, list(filtered_flows.user_flow_ids), add_to_output=True
+        )
+        log_llm(
+            logger=structlogger,
+            log_module="LLMBasedCommandGenerator",
+            log_event="llm_based_command_generator.predict_commands.filtered_flows",
+            message=message.data,
+            enabled_flow_retrieval=self.flow_retrieval is not None,
+            relevant_flows=list(filtered_flows.user_flow_ids),
+        )
+        return filtered_flows
+
+    async def invoke_llm(self, prompt: Text) -> Optional[Text]:
+        """Use LLM to generate a response.
+
+        Args:
+            prompt: The prompt to send to the LLM.
+
+        Returns:
+            The generated text.
+
+        Raises:
+            ProviderClientAPIException if an error during API call.
+        """
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+        try:
+            return await llm.apredict(prompt)
+        except Exception as e:
+            # unfortunately, langchain does not wrap LLM exceptions which means
+            # we have to catch all exceptions here
+            structlogger.error("llm_based_command_generator.llm.error", error=e)
+            raise ProviderClientAPIException(
+                message="LLM call exception", original_exception=e
+            )
+
+    @staticmethod
+    def start_flow_by_name(flow_name: str, flows: FlowsList) -> List[Command]:
+        """Start a flow by name.
+
+        If the flow does not exist, no command is returned.
+        """
+        if flow_name in flows.user_flow_ids:
+            return [StartFlowCommand(flow=flow_name)]
+        else:
+            structlogger.debug(
+                "llm_command_generator.flow.start_invalid_flow_id", flow=flow_name
+            )
+            return []
+
+    @staticmethod
+    def is_none_value(value: str) -> bool:
+        """Check if the value is a none value."""
+        return value in {
+            "[missing information]",
+            "[missing]",
+            "None",
+            "undefined",
+            "null",
+        }
+
+    @staticmethod
+    def clean_extracted_value(value: str) -> str:
+        """Clean up the extracted value from the llm."""
+        # replace any combination of single quotes, double quotes, and spaces
+        # from the beginning and end of the string
+        return value.strip("'\" ")
+
+    @classmethod
+    def get_nullable_slot_value(cls, slot_value: str) -> Union[str, None]:
+        """Get the slot value or None if the value is a none value.
+
+        Args:
+            slot_value: the value to coerce
+
+        Returns:
+            The slot value or None if the value is a none value.
+        """
+        return slot_value if not cls.is_none_value(slot_value) else None
+
+    def prepare_flows_for_template(
+        self, flows: FlowsList, tracker: DialogueStateTracker
+    ) -> List[Dict[str, Any]]:
+        """Format data on available flows for insertion into the prompt template.
+
+        Args:
+            flows: The flows available to the user.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            The inputs for the prompt template.
+        """
+        result = []
+        for flow in flows.user_flows:
+            slots_with_info = [
+                {
+                    "name": q.collect,
+                    "description": q.description,
+                    "allowed_values": allowed_values_for_slot(tracker.slots[q.collect]),
+                }
+                for q in flow.get_collect_steps()
+                if self.is_extractable(q, tracker)
+            ]
+            result.append(
+                {
+                    "name": flow.id,
+                    "description": flow.description,
+                    "slots": slots_with_info,
+                }
+            )
+        return result
+
+    @staticmethod
+    def is_extractable(
+        collect_step: CollectInformationFlowStep,
+        tracker: DialogueStateTracker,
+        current_step: Optional[FlowStep] = None,
+    ) -> bool:
+        """Check if the `collect` can be filled.
+
+        A collect slot can only be filled if the slot exist
+        and either the collect has been asked already or the
+        slot has been filled already.
+
+        Args:
+            collect_step: The collect_information step.
+            tracker: The tracker containing the current state of the conversation.
+            current_step: The current step in the flow.
+
+        Returns:
+            `True` if the slot can be filled, `False` otherwise.
+        """
+        slot = tracker.slots.get(collect_step.collect)
+        if slot is None:
+            return False
+
+        return (
+            # we can fill because this is a slot that can be filled ahead of time
+            not collect_step.ask_before_filling
+            # we can fill because the slot has been filled already
+            or slot.has_been_set
+            # we can fill because the is currently getting asked
+            or (
+                current_step is not None
+                and isinstance(current_step, CollectInformationFlowStep)
+                and current_step.collect == collect_step.collect
+            )
+        )
+
+    @staticmethod
+    def get_slot_value(tracker: DialogueStateTracker, slot_name: str) -> str:
+        """Get the slot value from the tracker.
+
+        Args:
+            tracker: The tracker containing the current state of the conversation.
+            slot_name: The name of the slot.
+
+        Returns:
+            The slot value as a string.
+        """
+        slot_value = tracker.get_slot(slot_name)
+        if slot_value is None:
+            return "undefined"
+        else:
+            return str(slot_value)
+
+    def prepare_current_flow_slots_for_template(
+        self, top_flow: Flow, current_step: FlowStep, tracker: DialogueStateTracker
+    ) -> List[Dict[str, Any]]:
+        """Prepare the current flow slots for the template.
+
+        Args:
+            top_flow: The top flow.
+            current_step: The current step in the flow.
+            tracker: The tracker containing the current state of the conversation.
+
+        Returns:
+            The slots with values, types, allowed values and a description.
+        """
+        if top_flow is not None:
+            flow_slots = [
+                {
+                    "name": collect_step.collect,
+                    "value": self.get_slot_value(tracker, collect_step.collect),
+                    "type": tracker.slots[collect_step.collect].type_name,
+                    "allowed_values": allowed_values_for_slot(
+                        tracker.slots[collect_step.collect]
+                    ),
+                    "description": collect_step.description,
+                }
+                for collect_step in top_flow.get_collect_steps()
+                if self.is_extractable(collect_step, tracker, current_step)
+            ]
+        else:
+            flow_slots = []
+        return flow_slots
+
+    def prepare_current_slot_for_template(
+        self, current_step: FlowStep
+    ) -> Tuple[Union[str, None], Union[str, None]]:
+        """Prepare the current slot for the template."""
+        return (
+            (current_step.collect, current_step.description)
+            if isinstance(current_step, CollectInformationFlowStep)
+            else (None, None)
+        )