rasa-pro 3.13.0.dev7__py3-none-any.whl → 3.13.0.dev9__py3-none-any.whl

rasa/core/policies/enterprise_search_policy.py

@@ -1,7 +1,8 @@
+import dataclasses
 import importlib.resources
 import json
 import re
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Text
 
 import dotenv
 import structlog
@@ -9,6 +10,7 @@ from jinja2 import Template
 from pydantic import ValidationError
 
 import rasa.shared.utils.io
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.core.constants import (
     POLICY_MAX_HISTORY,
     POLICY_PRIORITY,
@@ -23,7 +25,6 @@ from rasa.core.information_retrieval import (
 )
 from rasa.core.information_retrieval.faiss import FAISS_Store
 from rasa.core.policies.policy import Policy, PolicyPrediction
-from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
 )
@@ -53,7 +54,9 @@ from rasa.shared.constants import (
     MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
+    PROMPT_TEMPLATE_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
+    RASA_PATTERN_CANNOT_HANDLE_NO_RELEVANT_ANSWER,
     TEMPERATURE_CONFIG_KEY,
     TIMEOUT_CONFIG_KEY,
 )
@@ -78,7 +81,6 @@ from rasa.shared.nlu.training_data.training_data import TrainingData
 from rasa.shared.providers.embedding._langchain_embedding_client_adapter import (
     _LangchainEmbeddingClientAdapter,
 )
-from rasa.shared.providers.llm.llm_client import LLMClient
 from rasa.shared.providers.llm.llm_response import LLMResponse, measure_llm_latency
 from rasa.shared.utils.cli import print_error_and_exit
 from rasa.shared.utils.constants import (
@@ -93,6 +95,7 @@ from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+    check_prompt_config_keys_and_warn_if_deprecated,
     embedder_factory,
     get_prompt_template,
     llm_factory,
@@ -113,7 +116,7 @@ if TYPE_CHECKING:
 
 from rasa.utils.log_utils import log_llm
 
-logger = structlog.get_logger()
+structlogger = structlog.get_logger()
 
 dotenv.load_dotenv("./.env")
 
@@ -124,6 +127,7 @@ VECTOR_STORE_THRESHOLD_PROPERTY = "threshold"
 TRACE_TOKENS_PROPERTY = "trace_prompt_tokens"
 CITATION_ENABLED_PROPERTY = "citation_enabled"
 USE_LLM_PROPERTY = "use_generative_llm"
+CHECK_RELEVANCY_PROPERTY = "check_relevancy"
 MAX_MESSAGES_IN_QUERY_KEY = "max_messages_in_query"
 
 DEFAULT_VECTOR_STORE_TYPE = "faiss"
@@ -134,6 +138,10 @@ DEFAULT_VECTOR_STORE = {
     VECTOR_STORE_THRESHOLD_PROPERTY: DEFAULT_VECTOR_STORE_THRESHOLD,
 }
 
+DEFAULT_CHECK_RELEVANCY_PROPERTY = False
+DEFAULT_USE_LLM_PROPERTY = True
+DEFAULT_CITATION_ENABLED_PROPERTY = False
+
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     MODEL_CONFIG_KEY: DEFAULT_OPENAI_CHAT_MODEL_NAME,
@@ -162,6 +170,18 @@ DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE = importlib.resources.re
     "rasa.core.policies", "enterprise_search_prompt_with_citation_template.jinja2"
 )
 
+DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_RELEVANCY_CHECK_AND_CITATION_TEMPLATE = (
+    importlib.resources.read_text(
+        "rasa.core.policies",
+        "enterprise_search_prompt_with_relevancy_check_and_citation_template.jinja2",
+    )
+)
+
+# TODO: Update this pattern once the experiments are done
+_ENTERPRISE_SEARCH_ANSWER_NOT_RELEVANT_PATTERN = re.compile(
+    r"\[NO_RELEVANT_ANSWER_FOUND\]"
+)
+
 
 class VectorStoreConnectionError(RasaException):
     """Exception raised for errors in connecting to the vector store."""
@@ -171,6 +191,12 @@ class VectorStoreConfigurationError(RasaException):
     """Exception raised for errors in vector store configuration."""
 
 
+@dataclasses.dataclass
+class _RelevancyCheckResponse:
+    answer: Optional[str]
+    relevant: bool
+
+
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
@@ -220,6 +246,13 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         """Constructs a new Policy object."""
         super().__init__(config, model_storage, resource, execution_context, featurizer)
 
+        # Check for deprecated keys and issue a warning if those are used
+        check_prompt_config_keys_and_warn_if_deprecated(
+            config, "enterprise_search_policy"
+        )
+        # Check for mutual exclusivity of extractive and generative search
+        self._check_and_warn_mutual_exclusivity_of_extractive_and_generative_search()
+
         # Resolve LLM config
         self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
             self.config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
@@ -234,6 +267,9 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         self.vector_store_config = self.config.get(
             VECTOR_STORE_PROPERTY, DEFAULT_VECTOR_STORE
         )
+        self.vector_search_threshold = self.vector_store_config.get(
+            VECTOR_STORE_THRESHOLD_PROPERTY, DEFAULT_VECTOR_STORE_THRESHOLD
+        )
 
         # Embeddings configuration for encoding the search query
         self.embeddings_config = (
@@ -249,30 +285,49 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Maximum number of messages to include in the search query
         self.max_messages_in_query = self.config.get(MAX_MESSAGES_IN_QUERY_KEY, 2)
 
-        # boolean to enable/disable tracing of prompt tokens
+        # Boolean to enable/disable tracing of prompt tokens
         self.trace_prompt_tokens = self.config.get(TRACE_TOKENS_PROPERTY, False)
 
-        # boolean to enable/disable the use of LLM for response generation
-        self.use_llm = self.config.get(USE_LLM_PROPERTY, True)
+        # Boolean to enable/disable the use of LLM for response generation
+        self.use_llm = self.config.get(USE_LLM_PROPERTY, DEFAULT_USE_LLM_PROPERTY)
 
-        # boolean to enable/disable citation generation
-        self.citation_enabled = self.config.get(CITATION_ENABLED_PROPERTY, False)
+        # Boolean to enable/disable citation generation. This flag enables citation
+        # logic, but it only takes effect if `use_llm` is True.
+        self.citation_enabled = self.config.get(
+            CITATION_ENABLED_PROPERTY, DEFAULT_CITATION_ENABLED_PROPERTY
+        )
 
-        self.prompt_template = prompt_template or get_prompt_template(
-            self.config.get(PROMPT_CONFIG_KEY),
-            DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
-            log_source_component=EnterpriseSearchPolicy.__name__,
-            log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
+        # Boolean to enable/disable the use of relevancy check alongside answer
+        # generation. This flag enables citation logic, but it only takes effect if
+        # `use_llm` is True.
+        self.relevancy_check_enabled = self.config.get(
+            CHECK_RELEVANCY_PROPERTY, DEFAULT_CHECK_RELEVANCY_PROPERTY
         )
-        self.citation_prompt_template = get_prompt_template(
-            self.config.get(PROMPT_CONFIG_KEY),
-            DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE,
-            log_source_component=EnterpriseSearchPolicy.__name__,
-            log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
+
+        # Resolve the prompt template. The prompt will only be used if the 'use_llm' is
+        # set to True.
+        self.prompt_template = prompt_template or self._resolve_prompt_template(
+            self.config, LOG_COMPONENT_SOURCE_METHOD_INIT
         )
-        # If citation is enabled, use the citation prompt template
-        if self.citation_enabled:
-            self.prompt_template = self.citation_prompt_template
+
+    def _check_and_warn_mutual_exclusivity_of_extractive_and_generative_search(
+        self,
+    ) -> None:
+        if self.config.get(
+            CHECK_RELEVANCY_PROPERTY, DEFAULT_CHECK_RELEVANCY_PROPERTY
+        ) and not self.config.get(USE_LLM_PROPERTY, DEFAULT_USE_LLM_PROPERTY):
+            structlogger.warning(
+                "enterprise_search_policy.init"
+                ".relevancy_check_enabled_with_disabled_generative_search",
+                event_info=(
+                    f"The config parameter '{CHECK_RELEVANCY_PROPERTY}' is set to"
+                    f"'True', but the generative search is disabled (config"
+                    f"parameter '{USE_LLM_PROPERTY}' is set to 'False'). As a result, "
+                    "the relevancy check for the generative search will be disabled. "
+                    f"To use this check, set the config parameter '{USE_LLM_PROPERTY}' "
+                    f"to `True`."
+                ),
+            )
 
     @classmethod
     def _create_plain_embedder(cls, config: Dict[Text, Any]) -> "Embeddings":
@@ -366,7 +421,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         try:
             embeddings = self._create_plain_embedder(self.config)
         except (ValidationError, Exception) as e:
-            logger.error(
+            structlogger.error(
                 "enterprise_search_policy.train.embedder_instantiation_failed",
                 message="Unable to instantiate the embedding client.",
                 error=e,
@@ -377,16 +432,19 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             )
 
         if store_type == DEFAULT_VECTOR_STORE_TYPE:
-            logger.info("enterprise_search_policy.train.faiss")
+            structlogger.info("enterprise_search_policy.train.faiss")
             with self._model_storage.write_to(self._resource) as path:
                 self.vector_store = FAISS_Store(
                     docs_folder=self.vector_store_config.get(SOURCE_PROPERTY),
                     embeddings=embeddings,
                     index_path=path,
                     create_index=True,
+                    parse_as_faq_pairs=not self.use_llm,
                 )
         else:
-            logger.info("enterprise_search_policy.train.custom", store_type=store_type)
+            structlogger.info(
+                "enterprise_search_policy.train.custom", store_type=store_type
+            )
 
         # telemetry call to track training completion
         track_enterprise_search_policy_train_completed(
@@ -402,6 +460,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
             llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
+            relevancy_check_enabled=self.relevancy_check_enabled,
         )
         self.persist()
         return self._resource
@@ -454,7 +513,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         config = endpoints.vector_store if endpoints else None
         store_type = self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY)
         if config is None and store_type != DEFAULT_VECTOR_STORE_TYPE:
-            logger.error(
+            structlogger.error(
                 "enterprise_search_policy._connect_vector_store_or_raise.no_config"
             )
             raise VectorStoreConfigurationError(
@@ -464,7 +523,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         try:
             self.vector_store.connect(config)  # type: ignore
         except Exception as e:
-            logger.error(
+            structlogger.error(
                 "enterprise_search_policy._connect_vector_store_or_raise.connect_error",
                 error=e,
                 config=config,
@@ -490,14 +549,14 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                 transcript.append(sanitize_message_for_prompt(event.text))
 
         search_query = " ".join(transcript[-history:][::-1])
-        logger.debug("search_query", search_query=search_query)
+        structlogger.debug("search_query", search_query=search_query)
         return search_query
 
     async def predict_action_probabilities(  # type: ignore[override]
         self,
         tracker: DialogueStateTracker,
         domain: Domain,
-        endpoints: Optional[AvailableEndpoints],
+        endpoints: Optional[AvailableEndpoints] = None,
         rule_only_data: Optional[Dict[Text, Any]] = None,
         **kwargs: Any,
     ) -> PolicyPrediction:
@@ -516,23 +575,20 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
              The prediction.
         """
         logger_key = "enterprise_search_policy.predict_action_probabilities"
-        vector_search_threshold = self.vector_store_config.get(
-            VECTOR_STORE_THRESHOLD_PROPERTY, DEFAULT_VECTOR_STORE_THRESHOLD
-        )
-        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
+
         if not self.supports_current_stack_frame(
             tracker, False, False
         ) or self.should_abstain_in_coexistence(tracker, True):
             return self._prediction(self._default_predictions(domain))
 
         if not self.vector_store:
-            logger.error(f"{logger_key}.no_vector_store")
+            structlogger.error(f"{logger_key}.no_vector_store")
             return self._create_prediction_internal_error(domain, tracker)
 
         try:
             self._connect_vector_store_or_raise(endpoints)
         except (VectorStoreConfigurationError, VectorStoreConnectionError) as e:
-            logger.error(f"{logger_key}.connection_error", error=e)
+            structlogger.error(f"{logger_key}.connection_error", error=e)
             return self._create_prediction_internal_error(domain, tracker)
 
         search_query = self._prepare_search_query(
@@ -544,20 +600,19 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             documents = await self.vector_store.search(
                 query=search_query,
                 tracker_state=tracker_state,
-                threshold=vector_search_threshold,
+                threshold=self.vector_search_threshold,
             )
         except InformationRetrievalException as e:
-            logger.error(f"{logger_key}.search_error", error=e)
+            structlogger.error(f"{logger_key}.search_error", error=e)
             return self._create_prediction_internal_error(domain, tracker)
 
         if not documents.results:
-            logger.info(f"{logger_key}.no_documents")
+            structlogger.info(f"{logger_key}.no_documents")
             return self._create_prediction_cannot_handle(domain, tracker)
 
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
-            llm_response = await self._generate_llm_answer(llm, prompt)
-            llm_response = LLMResponse.ensure_llm_response(llm_response)
+            llm_response = await self._invoke_llm(prompt)
 
             self._add_prompt_and_llm_response_to_latest_message(
                 tracker=tracker,
@@ -567,24 +622,38 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             )
 
             if llm_response is None or not llm_response.choices:
-                logger.debug(f"{logger_key}.no_llm_response")
+                structlogger.debug(f"{logger_key}.no_llm_response")
                 response = None
             else:
                 llm_answer = llm_response.choices[0]
 
+                if self.relevancy_check_enabled:
+                    relevancy_response = self._parse_llm_relevancy_check_response(
+                        llm_answer
+                    )
+                    if not relevancy_response.relevant:
+                        structlogger.debug(f"{logger_key}.answer_not_relevant")
+                        return self._create_prediction_cannot_handle(
+                            domain,
+                            tracker,
+                            RASA_PATTERN_CANNOT_HANDLE_NO_RELEVANT_ANSWER,
+                        )
+
                 if self.citation_enabled:
                     llm_answer = self.post_process_citations(llm_answer)
 
-                logger.debug(f"{logger_key}.llm_answer", llm_answer=llm_answer)
+                structlogger.debug(
+                    f"{logger_key}.llm_answer", prompt=prompt, llm_answer=llm_answer
+                )
                 response = llm_answer
         else:
             response = documents.results[0].metadata.get("answer", None)
             if not response:
-                logger.error(
+                structlogger.error(
                     f"{logger_key}.answer_key_missing_in_metadata",
                     search_results=documents.results,
                 )
-            logger.debug(
+            structlogger.debug(
                 "enterprise_search_policy.predict_action_probabilities.no_llm",
                 search_results=documents,
             )
@@ -616,6 +685,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             or self.llm_config.get(MODEL_NAME_CONFIG_KEY),
             llm_model_group_id=self.llm_config.get(MODEL_GROUP_ID_CONFIG_KEY),
             citation_enabled=self.citation_enabled,
+            relevancy_check_enabled=self.relevancy_check_enabled,
         )
         return self._create_prediction(
             domain=domain, tracker=tracker, action_metadata=action_metadata
@@ -639,11 +709,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             ),
             "docs": documents,
             "slots": self._prepare_slots_for_template(tracker),
+            "check_relevancy": self.relevancy_check_enabled,
             "citation_enabled": self.citation_enabled,
         }
         prompt = Template(self.prompt_template).render(**inputs)
         log_llm(
-            logger=logger,
+            logger=structlogger,
             log_module="EnterpriseSearchPolicy",
             log_event="enterprise_search_policy._render_prompt.prompt_rendered",
             prompt=prompt,
@@ -651,9 +722,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         return prompt
 
     @measure_llm_latency
-    async def _generate_llm_answer(
-        self, llm: LLMClient, prompt: Text
-    ) -> Optional[LLMResponse]:
+    async def _invoke_llm(self, prompt: Text) -> Optional[LLMResponse]:
         """Fetches an LLM completion for the provided prompt.
 
         Args:
@@ -663,17 +732,32 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         Returns:
             An LLMResponse object, or None if the call fails.
         """
+        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
         try:
-            return await llm.acompletion(prompt)
+            response = await llm.acompletion(prompt)
+            return LLMResponse.ensure_llm_response(response)
         except Exception as e:
             # unfortunately, langchain does not wrap LLM exceptions which means
             # we have to catch all exceptions here
-            logger.error(
+            structlogger.error(
                 "enterprise_search_policy._generate_llm_answer.llm_error",
                 error=e,
             )
             return None
 
+    def _parse_llm_relevancy_check_response(
+        self, llm_answer: str
+    ) -> _RelevancyCheckResponse:
+        """Checks if the LLM response is relevant by parsing it."""
+        answer_relevant = not _ENTERPRISE_SEARCH_ANSWER_NOT_RELEVANT_PATTERN.search(
+            llm_answer
+        )
+        structlogger.debug("")
+        return _RelevancyCheckResponse(
+            answer=llm_answer if answer_relevant else None,
+            relevant=answer_relevant,
+        )
+
     def _create_prediction(
         self,
         domain: Domain,
@@ -708,10 +792,18 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         )
 
     def _create_prediction_cannot_handle(
-        self, domain: Domain, tracker: DialogueStateTracker
+        self,
+        domain: Domain,
+        tracker: DialogueStateTracker,
+        reason: Optional[str] = None,
     ) -> PolicyPrediction:
+        cannot_handle_stack_frame = (
+            CannotHandlePatternFlowStackFrame(reason=reason)
+            if reason is not None
+            else CannotHandlePatternFlowStackFrame()
+        )
         return self._create_prediction_for_pattern(
-            domain, tracker, CannotHandlePatternFlowStackFrame()
+            domain, tracker, cannot_handle_stack_frame
         )
 
     def _create_prediction_for_pattern(
@@ -780,7 +872,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                     path / ENTERPRISE_SEARCH_PROMPT_FILE_NAME
                 )
         except (FileNotFoundError, FileIOException) as e:
-            logger.warning(
+            structlogger.warning(
                 "enterprise_search_policy.load.failed", error=e, resource=resource.name
             )
 
@@ -790,7 +882,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
 
         embeddings = cls._create_plain_embedder(config)
 
-        logger.info("enterprise_search_policy.load", config=config)
+        structlogger.info("enterprise_search_policy.load", config=config)
         if store_type == DEFAULT_VECTOR_STORE_TYPE:
             # if a vector store is not specified,
             # default to using FAISS with the index stored in the model
@@ -801,6 +893,9 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                     index_path=path,
                     docs_folder=None,
                     create_index=False,
+                    parse_as_faq_pairs=not config.get(
+                        USE_LLM_PROPERTY, DEFAULT_USE_LLM_PROPERTY
+                    ),
                 )
         else:
             vector_store = create_from_endpoint_config(
@@ -849,15 +944,12 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
     @classmethod
     def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint of enterprise search policy for the graph."""
-        local_knowledge_data = cls._get_local_knowledge_data(config)
-
-        prompt_template = get_prompt_template(
-            config.get(PROMPT_CONFIG_KEY),
-            DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE,
-            log_source_component=EnterpriseSearchPolicy.__name__,
-            log_source_method=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+        prompt_template = cls._resolve_prompt_template(
+            config, LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
         )
 
+        local_knowledge_data = cls._get_local_knowledge_data(config)
+
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
         )
@@ -881,7 +973,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         Returns:
             The post-processed LLM answer.
         """
-        logger.debug(
+        structlogger.debug(
             "enterprise_search_policy.post_process_citations", llm_answer=llm_answer
         )
 
@@ -982,3 +1074,111 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             log_source_method,
             EnterpriseSearchPolicy.__name__,
         )
+
+    @classmethod
+    def get_system_default_prompt_based_on_config(cls, config: Dict[str, Any]) -> str:
+        """
+        Resolves the default prompt template for Enterprise Search Policy based on
+        the component's configuration.
+
+        - The old prompt is selected when both citation and relevancy check are either
+          disabled or not set in the configuration.
+        - The citation prompt is used when citation is enabled and relevancy check is
+          either disabled or not set in the configuration.
+        - The relevancy check prompt is only used when relevancy check is enabled.
+
+        Args:
+            config: The component's configuration.
+
+        Returns:
+            The resolved jinja prompt template as a string.
+        """
+
+        # Get the feature flags
+        citation_enabled = config.get(
+            CITATION_ENABLED_PROPERTY, DEFAULT_CITATION_ENABLED_PROPERTY
+        )
+        relevancy_check_enabled = config.get(
+            CHECK_RELEVANCY_PROPERTY, DEFAULT_CHECK_RELEVANCY_PROPERTY
+        )
+
+        # Based on the enabled features (citation, relevancy check) fetch the
+        # appropriate default prompt
+        default_prompt = cls._select_default_prompt_template_based_on_features(
+            relevancy_check_enabled, citation_enabled
+        )
+
+        return default_prompt
+
+    @classmethod
+    def _resolve_prompt_template(
+        cls,
+        config: dict,
+        log_source_method: Literal["init", "fingerprint"],
+    ) -> str:
+        """
+        Resolves the prompt template to use for the Enterprise Search Policy's
+        generative search.
+
+        Checks if a custom template is provided via component's configuration. If not,
+        it selects the appropriate default template based on the enabled features
+        (citation and relevancy check).
+
+        Args:
+            config: The component's configuration.
+            log_source_method: The name of the method or function emitting the log for
+                better traceability.
+        Returns:
+            The resolved jinja prompt template as a string.
+        """
+
+        # Read the template path from the configuration if available.
+        # The deprecated 'prompt' has a lower priority compared to 'prompt_template'
+        config_defined_prompt = (
+            config.get(PROMPT_TEMPLATE_CONFIG_KEY)
+            or config.get(PROMPT_CONFIG_KEY)
+            or None
+        )
+        # Select the default prompt based on the features set in the config.
+        default_prompt = cls.get_system_default_prompt_based_on_config(config)
+
+        return get_prompt_template(
+            config_defined_prompt,
+            default_prompt,
+            log_source_component=EnterpriseSearchPolicy.__name__,
+            log_source_method=log_source_method,
+        )
+
+    @classmethod
+    def _select_default_prompt_template_based_on_features(
+        cls,
+        relevancy_check_enabled: bool,
+        citation_enabled: bool,
+    ) -> str:
+        """
+        Returns the appropriate default prompt template based on the feature flags.
+
+        The selection follows this priority:
+        1. If relevancy check is enabled, return the prompt that includes both relevancy
+           and citation blocks.
+        2. If only citation is enabled, return the prompt with citation blocks.
+        3. Otherwise, fall back to the legacy default prompt template.
+
+        Args:
+            relevancy_check_enabled: Whether the LLM-generated answer should undergo
+                relevancy evaluation.
+            citation_enabled: Whether citations should be included in the generated
+                answer.
+
+        Returns:
+            The default prompt template corresponding to the enabled features.
+        """
+        if relevancy_check_enabled:
+            # ES prompt that has relevancy check and citations blocks
+            return DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_RELEVANCY_CHECK_AND_CITATION_TEMPLATE  # noqa: E501
+        elif citation_enabled:
+            # ES prompt with citation's block - backward compatibility
+            return DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE
+        else:
+            # Legacy ES prompt - backward compatibility
+            return DEFAULT_ENTERPRISE_SEARCH_PROMPT_TEMPLATE

rasa/core/policies/enterprise_search_prompt_with_relevancy_check_and_citation_template.jinja2

@@ -0,0 +1,63 @@
+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.text }}
+{% 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 %}
+
+{% if check_relevancy %}
+If answer is not relevant output: "[NO_RELEVANT_ANSWER_FOUND]"
+{% endif %}
+Your answer: