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

rasa/core/policies/enterprise_search_prompt_template.jinja2

@@ -0,0 +1,25 @@
+Given the following information, please provide an answer based on the provided documents and the context of the recent conversation.
+If the answer is not known or cannot be determined from the provided documents or context, please state that you do not know to the user.
+
+### Relevant Documents
+Use the following documents to answer the question:
+{% for doc in docs %}
+{{ loop.index }}. {{ doc.metadata }}
+{{ doc.text }}
+{% endfor %}
+
+{% if slots|length > 0 %}
+### Slots or Variables
+Here are the variables of the currently active conversation which may be used to answer the question:
+{% for slot in slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}
+{% endfor %}
+{% endif %}
+
+### Current Conversation
+Transcript of the current conversation, use it to determine the context of the question:
+{{ current_conversation }}
+
+Based on the above, please formulate an answer to the question or request in the user's last message. 
+It is important that you ensure the answer is grounded in the provided documents and conversation context. 
+Avoid speculating or making assumptions beyond the given information and keep your answers short, 2 to 3 sentences at most.

rasa/core/policies/enterprise_search_prompt_with_citation_template.jinja2

@@ -0,0 +1,60 @@
+Given the following information, please provide an answer based on the provided documents and the context of the recent conversation.
+If the answer is not known or cannot be determined from the provided documents or context, please state that you do not know to the user.
+### Relevant Documents
+Use the following documents to answer the question:
+{% for doc in docs %}
+{{ loop.cycle("*")}}. {{ doc.metadata }}
+{{ doc.page_content }}
+{% endfor %}
+
+{% if citation_enabled %}
+### Citing Sources
+Find the sources from the documents that are most relevant to answering the question.
+The sources must be extracted from the given document metadata source property and not from the conversation context.
+If there are no relevant sources, write "No relevant sources" instead.
+
+For each source you cite, follow a 1-based numbering system for citations.
+Start with [1] for the first source you refer to, regardless of its index in the provided list of documents.
+If you cite another source, use the next number in sequence, [2], and so on.
+Ensure each source is only assigned one number, even if referenced multiple times.
+If you refer back to a previously cited source, use its originally assigned number.
+
+For example, if you first cite the third source in the list, refer to it as [1].
+If you then cite the first source in the list, refer to it as [2].
+If you mention the third source again, still refer to it as [1].
+
+Don't say "According to Source [1]" when answering. Instead, make references to sources relevant to each section of the answer solely by adding the bracketed number at the end of the relevant sentence.
+#### Formatting
+First print the answer with in-text citations which follow a numbered order starting with index 1, then add the sources section.
+The format of your overall answer must look like what's shown between the <example></example> tags.
+Make sure to follow the formatting exactly and remove any line breaks or whitespaces between the answer and the Sources section.
+<example>
+You can use flows to model business logic in Rasa assistants. [1] You can use the Enterprise Search Policy to search vector stores for relevant knowledge base documents. [2]
+Sources:
+[1] https://rasa.com/docs/rasa-pro/concepts/flows
+[2] https://rasa.com/docs/rasa-pro/concepts/policies/enterprise-search-policy
+</example>
+{% endif %}
+
+{% if slots|length > 0 %}
+### Slots or Variables
+Here are the variables of the currently active conversation which may be used to answer the question:
+{% for slot in slots -%}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}
+{% endfor %}
+{% endif %}
+### Current Conversation
+Transcript of the current conversation, use it to determine the context of the question:
+{{ current_conversation }}
+
+
+## Answering the Question
+Based on the above sections, please formulate an answer to the question or request in the user's last message.
+It is important that you ensure the answer is grounded in the provided documents and conversation context.
+Avoid speculating or making assumptions beyond the given information and keep your answers short, 2 to 3 sentences at most.
+
+{% if citation_enabled %}
+If you are unable to find an answer in the given relevant documents, do not cite sources from elsewhere in the conversation context.
+{% endif %}
+
+Your answer:

rasa/core/policies/flow_policy.py

@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Text, List, Optional
+from rasa.core.policies.flows import flow_executor
+
+from rasa.core.policies.flows.flow_exceptions import FlowCircuitBreakerTrippedException
+from rasa.dialogue_understanding.patterns.internal_error import (
+    InternalErrorPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    DialogueStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    end_top_user_flow,
+)
+
+from rasa.core.constants import (
+    FLOW_POLICY_PRIORITY,
+    POLICY_MAX_HISTORY,
+    POLICY_PRIORITY,
+)
+
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
+from rasa.core.policies.policy import Policy, PolicyPrediction
+from rasa.engine.graph import 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.generator import TrackerWithCachedStates
+from rasa.shared.core.trackers import (
+    DialogueStateTracker,
+)
+import structlog
+
+structlogger = structlog.get_logger()
+
+
+@DefaultV1Recipe.register(
+    DefaultV1Recipe.ComponentType.POLICY_WITHOUT_END_TO_END_SUPPORT, is_trainable=False
+)
+class FlowPolicy(Policy):
+    """A policy which handles the flow of the conversation based on flows.
+
+    Flows are loaded from files during training. During prediction,
+    the flows are applied.
+    """
+
+    @staticmethod
+    def does_support_stack_frame(frame: DialogueStackFrame) -> bool:
+        """Checks if the policy supports the topmost frame on the dialogue stack.
+
+        If `False` is returned, the policy will abstain from making a prediction.
+
+        Args:
+            frame: The frame to check.
+
+        Returns:
+        `True` if the policy supports the frame, `False` otherwise.
+        """
+        return isinstance(frame, BaseFlowStackFrame)
+
+    @staticmethod
+    def get_default_config() -> Dict[Text, Any]:
+        """Returns the default config (see parent class for full docstring)."""
+        # please make sure to update the docs when changing a default parameter
+        return {
+            POLICY_PRIORITY: FLOW_POLICY_PRIORITY,
+            POLICY_MAX_HISTORY: None,
+        }
+
+    def __init__(
+        self,
+        config: Dict[Text, Any],
+        model_storage: ModelStorage,
+        resource: Resource,
+        execution_context: ExecutionContext,
+        featurizer: Optional[TrackerFeaturizer] = None,
+    ) -> None:
+        """Constructs a new Policy object."""
+        super().__init__(config, model_storage, resource, execution_context, featurizer)
+
+        self.max_history = self.config.get(POLICY_MAX_HISTORY)
+        self.resource = resource
+
+    def train(
+        self,
+        training_trackers: List[TrackerWithCachedStates],
+        domain: Domain,
+        **kwargs: Any,
+    ) -> Resource:
+        """Trains a policy.
+
+        Args:
+            training_trackers: The story and rules trackers from the training data.
+            domain: The model's domain.
+            **kwargs: Depending on the specified `needs` section and the resulting
+                graph structure the policy can use different input to train itself.
+
+        Returns:
+            A policy must return its resource locator so that potential children nodes
+            can load the policy from the resource.
+        """
+        return self.resource
+
+    async def predict_action_probabilities(
+        self,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        rule_only_data: Optional[Dict[Text, Any]] = None,
+        flows: Optional[FlowsList] = None,
+        **kwargs: Any,
+    ) -> PolicyPrediction:
+        """Predicts the next action the bot should take after seeing the tracker.
+
+        Args:
+            tracker: The tracker containing the conversation history up to now.
+            domain: The model's domain.
+            rule_only_data: Slots and loops which are specific to rules and hence
+                should be ignored by this policy.
+            flows: The flows to use.
+            **kwargs: Depending on the specified `needs` section and the resulting
+                graph structure the policy can use different input to make predictions.
+
+        Returns:
+             The prediction.
+        """
+        if not self.supports_current_stack_frame(
+            tracker
+        ) or self.should_abstain_in_coexistence(tracker, True):
+            # if the policy doesn't support the current stack frame, we'll abstain
+            return self._prediction(self._default_predictions(domain))
+
+        flows = flows or FlowsList(underlying_flows=[])
+
+        # create executor and predict next action
+        try:
+            prediction = flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows
+            )
+            return self._create_prediction_result(
+                prediction.action_name,
+                domain,
+                prediction.score,
+                prediction.events,
+                prediction.metadata,
+            )
+        except FlowCircuitBreakerTrippedException as e:
+            structlogger.error(
+                "flow.circuit_breaker",
+                dialogue_stack=e.dialogue_stack,
+                number_of_steps_taken=e.number_of_steps_taken,
+                event_info=(
+                    "The flow circuit breaker tripped. "
+                    "There appears to be an infinite loop in the flows."
+                ),
+            )
+            # end the current flow and start the internal error flow
+            updated_stack = tracker.stack
+            updated_stack = end_top_user_flow(updated_stack)
+            updated_stack.push(InternalErrorPatternFlowStackFrame())
+            # we retry, with the internal error frame on the stack
+            events = tracker.create_stack_updated_events(updated_stack)
+            tracker.update_with_events(events)
+            prediction = flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows
+            )
+            collected_events = events + (prediction.events or [])
+            return self._create_prediction_result(
+                prediction.action_name,
+                domain,
+                prediction.score,
+                collected_events,
+                prediction.metadata,
+            )
+
+    def _create_prediction_result(
+        self,
+        action_name: Optional[Text],
+        domain: Domain,
+        score: float = 1.0,
+        events: Optional[List[Event]] = None,
+        action_metadata: Optional[Dict[Text, Any]] = None,
+    ) -> PolicyPrediction:
+        """Creates a prediction result.
+
+        Args:
+            action_name: The name of the predicted action.
+            domain: The model's domain.
+            score: The score of the predicted action.
+            events: The events to return.
+            action_metadata: The metadata of the predicted action.
+
+        Returns:
+            The prediction result where the score is used for one hot encoding.
+        """
+        result = self._default_predictions(domain)
+        if action_name:
+            result[domain.index_for_action(action_name)] = score
+        return self._prediction(
+            result, optional_events=events, action_metadata=action_metadata
+        )

rasa/core/policies/flows/flow_exceptions.py

@@ -0,0 +1,44 @@
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.shared.exceptions import RasaException
+
+
+class FlowException(RasaException):
+    """Exception that is raised when there is a problem with a flow."""
+
+    pass
+
+
+class FlowCircuitBreakerTrippedException(FlowException):
+    """Exception that is raised when the flow circuit breaker tripped.
+
+    The circuit breaker gets tripped when a flow seems to be stuck in
+    executing steps and does not make any progress."""
+
+    def __init__(
+        self, dialogue_stack: DialogueStack, number_of_steps_taken: int
+    ) -> None:
+        """Creates a `FlowCircuitBreakerTrippedException`.
+
+        Args:
+            dialogue_stack: The dialogue stack.
+            number_of_steps_taken: The number of steps that were taken.
+        """
+        super().__init__(
+            f"Flow circuit breaker tripped after {number_of_steps_taken} steps. "
+            "There appears to be an infinite loop in the flows."
+        )
+        self.dialogue_stack = dialogue_stack
+        self.number_of_steps_taken = number_of_steps_taken
+
+
+class NoNextStepInFlowException(FlowException):
+    """Exception that is raised when there is no next step in a flow."""
+
+    def __init__(self, dialogue_stack: DialogueStack) -> None:
+        """Creates a `NoNextStepInFlowException`.
+
+        Args:
+            dialogue_stack: The dialogue stack.
+        """
+        super().__init__("No next step can be selected for the flow.")
+        self.dialogue_stack = dialogue_stack