rasa-pro 3.13.0.dev2__py3-none-any.whl → 3.13.0.dev3__py3-none-any.whl

rasa/core/policies/enterprise_search_policy.py

@@ -1,10 +1,12 @@
 import importlib.resources
+import json
 import re
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text
 
 import dotenv
 import structlog
 from jinja2 import Template
+from pydantic import ValidationError
 
 import rasa.shared.utils.io
 from rasa.core.constants import (
@@ -14,9 +16,12 @@ from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
 from rasa.core.information_retrieval import (
+    InformationRetrieval,
+    InformationRetrievalException,
     SearchResult,
-    SearchResultList,
+    create_from_endpoint_config,
 )
+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 (
@@ -33,10 +38,6 @@ from rasa.dialogue_understanding.stack.frames import (
     PatternFlowStackFrame,
     SearchStackFrame,
 )
-from rasa.document_retrieval.constants import (
-    POST_PROCESSED_DOCUMENTS_KEY,
-    SEARCH_QUERY_KEY,
-)
 from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -44,7 +45,10 @@ from rasa.engine.storage.storage import ModelStorage
 from rasa.graph_components.providers.forms_provider import Forms
 from rasa.graph_components.providers.responses_provider import Responses
 from rasa.shared.constants import (
+    EMBEDDINGS_CONFIG_KEY,
     MODEL_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    MODEL_NAME_CONFIG_KEY,
     OPENAI_PROVIDER,
     PROMPT_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
@@ -56,10 +60,10 @@ from rasa.shared.core.constants import (
     DEFAULT_SLOT_NAMES,
 )
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event
+from rasa.shared.core.events import BotUttered, Event, UserUttered
 from rasa.shared.core.generator import TrackerWithCachedStates
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.exceptions import FileIOException
+from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
+from rasa.shared.exceptions import FileIOException, RasaException
 from rasa.shared.nlu.constants import (
     KEY_COMPONENT_NAME,
     KEY_LLM_RESPONSE_METADATA,
@@ -68,8 +72,16 @@ from rasa.shared.nlu.constants import (
     PROMPTS,
 )
 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 (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
     EmbeddingsHealthCheckMixin,
 )
@@ -77,13 +89,23 @@ from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheck
 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,
+    embedder_factory,
     get_prompt_template,
     llm_factory,
     resolve_model_client_config,
+    sanitize_message_for_prompt,
     tracker_as_readable_transcript,
 )
+from rasa.telemetry import (
+    track_enterprise_search_policy_predict,
+    track_enterprise_search_policy_train_completed,
+    track_enterprise_search_policy_train_started,
+)
 
 if TYPE_CHECKING:
+    from langchain.schema.embeddings import Embeddings
+
     from rasa.core.featurizers.tracker_featurizers import TrackerFeaturizer
 
 from rasa.utils.log_utils import log_llm
@@ -92,11 +114,22 @@ logger = structlog.get_logger()
 
 dotenv.load_dotenv("./.env")
 
+SOURCE_PROPERTY = "source"
+VECTOR_STORE_TYPE_PROPERTY = "type"
+VECTOR_STORE_PROPERTY = "vector_store"
+VECTOR_STORE_THRESHOLD_PROPERTY = "threshold"
 TRACE_TOKENS_PROPERTY = "trace_prompt_tokens"
 CITATION_ENABLED_PROPERTY = "citation_enabled"
 USE_LLM_PROPERTY = "use_generative_llm"
 MAX_MESSAGES_IN_QUERY_KEY = "max_messages_in_query"
 
+DEFAULT_VECTOR_STORE_TYPE = "faiss"
+DEFAULT_VECTOR_STORE_THRESHOLD = 0.0
+DEFAULT_VECTOR_STORE = {
+    VECTOR_STORE_TYPE_PROPERTY: DEFAULT_VECTOR_STORE_TYPE,
+    SOURCE_PROPERTY: "./docs",
+    VECTOR_STORE_THRESHOLD_PROPERTY: DEFAULT_VECTOR_STORE_THRESHOLD,
+}
 
 DEFAULT_LLM_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
@@ -107,6 +140,11 @@ DEFAULT_LLM_CONFIG = {
     "max_retries": 1,
 }
 
+DEFAULT_EMBEDDINGS_CONFIG = {
+    PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
+    "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
+}
+
 ENTERPRISE_SEARCH_PROMPT_FILE_NAME = "enterprise_search_policy_prompt.jinja2"
 ENTERPRISE_SEARCH_CONFIG_FILE_NAME = "config.json"
 
@@ -122,6 +160,14 @@ DEFAULT_ENTERPRISE_SEARCH_PROMPT_WITH_CITATION_TEMPLATE = importlib.resources.re
 )
 
 
+class VectorStoreConnectionError(RasaException):
+    """Exception raised for errors in connecting to the vector store."""
+
+
+class VectorStoreConfigurationError(RasaException):
+    """Exception raised for errors in vector store configuration."""
+
+
 @DefaultV1Recipe.register(
     DefaultV1Recipe.ComponentType.POLICY_WITH_END_TO_END_SUPPORT, is_trainable=True
 )
@@ -155,6 +201,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         """Returns the default config of the policy."""
         return {
             POLICY_PRIORITY: SEARCH_POLICY_PRIORITY,
+            VECTOR_STORE_PROPERTY: DEFAULT_VECTOR_STORE,
         }
 
     def __init__(
@@ -163,6 +210,7 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         model_storage: ModelStorage,
         resource: Resource,
         execution_context: ExecutionContext,
+        vector_store: Optional[InformationRetrieval] = None,
         featurizer: Optional["TrackerFeaturizer"] = None,
         prompt_template: Optional[Text] = None,
     ) -> None:
@@ -173,6 +221,21 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
             self.config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
         )
+        # Resolve embeddings config
+        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            self.config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
+        )
+
+        # Vector store object and configuration
+        self.vector_store = vector_store
+        self.vector_store_config = self.config.get(
+            VECTOR_STORE_PROPERTY, DEFAULT_VECTOR_STORE
+        )
+
+        # Embeddings configuration for encoding the search query
+        self.embeddings_config = (
+            self.config[EMBEDDINGS_CONFIG_KEY] or DEFAULT_EMBEDDINGS_CONFIG
+        )
 
         # LLM Configuration for response generation
         self.llm_config = self.config[LLM_CONFIG_KEY] or DEFAULT_LLM_CONFIG
@@ -180,6 +243,9 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Maximum number of turns to include in the prompt
         self.max_history = self.config.get(POLICY_MAX_HISTORY)
 
+        # 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
         self.trace_prompt_tokens = self.config.get(TRACE_TOKENS_PROPERTY, False)
 
@@ -192,15 +258,38 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         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,
         )
         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,
         )
         # If citation is enabled, use the citation prompt template
         if self.citation_enabled:
             self.prompt_template = self.citation_prompt_template
 
+    @classmethod
+    def _create_plain_embedder(cls, config: Dict[Text, Any]) -> "Embeddings":
+        """Creates an embedder based on the given configuration.
+
+        Returns:
+        The embedder.
+        """
+        # Copy the config so original config is not modified
+        config = config.copy()
+        # Resolve config and instantiate the embedding client
+        config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
+        )
+        client = embedder_factory(
+            config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
+        )
+        # Wrap the embedding client in the adapter
+        return _LangchainEmbeddingClientAdapter(client)
+
     @classmethod
     def _add_prompt_and_llm_response_to_latest_message(
         cls,
@@ -265,24 +354,52 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
         # Perform health checks for both LLM and embeddings client configs
         self._perform_health_checks(self.config, "enterprise_search_policy.train")
 
-        # # telemetry call to track training start
-        # track_enterprise_search_policy_train_started()
-        # # telemetry call to track training completion
-        # track_enterprise_search_policy_train_completed(
-        #     vector_store_type=store_type,
-        #     embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
-        #     embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
-        #     or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
-        #     embeddings_model_group_id=self.embeddings_config.get(
-        #         MODEL_GROUP_ID_CONFIG_KEY
-        #     ),
-        #     llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
-        #     llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
-        #     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,
-        # )
+        store_type = self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY)
+
+        # telemetry call to track training start
+        track_enterprise_search_policy_train_started()
 
+        # validate embedding configuration
+        try:
+            embeddings = self._create_plain_embedder(self.config)
+        except (ValidationError, Exception) as e:
+            logger.error(
+                "enterprise_search_policy.train.embedder_instantiation_failed",
+                message="Unable to instantiate the embedding client.",
+                error=e,
+            )
+            print_error_and_exit(
+                "Unable to create embedder. Please make sure you specified the "
+                f"required environment variables. Error: {e}"
+            )
+
+        if store_type == DEFAULT_VECTOR_STORE_TYPE:
+            logger.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,
+                )
+        else:
+            logger.info("enterprise_search_policy.train.custom", store_type=store_type)
+
+        # telemetry call to track training completion
+        track_enterprise_search_policy_train_completed(
+            vector_store_type=store_type,
+            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_config.get(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
+            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+            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,
+        )
         self.persist()
         return self._resource
 
@@ -319,6 +436,60 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                 )
         return template_slots
 
+    def _connect_vector_store_or_raise(
+        self, endpoints: Optional[AvailableEndpoints]
+    ) -> None:
+        """Connects to the vector store or raises an exception.
+
+        Raise exceptions for the following cases:
+        - The configuration is not specified
+        - Unable to connect to the vector store
+
+        Args:
+            endpoints: Endpoints configuration.
+        """
+        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(
+                "enterprise_search_policy._connect_vector_store_or_raise.no_config"
+            )
+            raise VectorStoreConfigurationError(
+                """No vector store specified. Please specify a vector
+                store in the endpoints configuration"""
+            )
+        try:
+            self.vector_store.connect(config)  # type: ignore
+        except Exception as e:
+            logger.error(
+                "enterprise_search_policy._connect_vector_store_or_raise.connect_error",
+                error=e,
+                config=config,
+            )
+            raise VectorStoreConnectionError(
+                f"Unable to connect to the vector store. Error: {e}"
+            )
+
+    def _prepare_search_query(self, tracker: DialogueStateTracker, history: int) -> str:
+        """Prepares the search query.
+        The search query is the last N messages in the conversation history.
+
+        Args:
+            tracker: The tracker containing the conversation history up to now.
+            history: The number of messages to include in the search query.
+
+        Returns:
+            The search query.
+        """
+        transcript = []
+        for event in tracker.applied_events():
+            if isinstance(event, UserUttered) or isinstance(event, BotUttered):
+                transcript.append(sanitize_message_for_prompt(event.text))
+
+        search_query = " ".join(transcript[-history:][::-1])
+        logger.debug("search_query", search_query=search_query)
+        return search_query
+
     async def predict_action_probabilities(  # type: ignore[override]
         self,
         tracker: DialogueStateTracker,
@@ -342,34 +513,44 @@ 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))
 
-        # retrieve documents from the latest message
-        # document retrieval happened earlier in the pipeline
-        if tracker.latest_message is None or tracker.latest_message.parse_data is None:
-            logger.info(f"{logger_key}.no_documents")
-            return self._create_prediction_cannot_handle(domain, tracker)
+        if not self.vector_store:
+            logger.error(f"{logger_key}.no_vector_store")
+            return self._create_prediction_internal_error(domain, tracker)
 
-        documents_data = tracker.latest_message.parse_data.get(
-            POST_PROCESSED_DOCUMENTS_KEY
-        )
+        try:
+            self._connect_vector_store_or_raise(endpoints)
+        except (VectorStoreConfigurationError, VectorStoreConnectionError) as e:
+            logger.error(f"{logger_key}.connection_error", error=e)
+            return self._create_prediction_internal_error(domain, tracker)
 
-        if not documents_data:
-            logger.info(f"{logger_key}.no_documents")
-            return self._create_prediction_cannot_handle(domain, tracker)
+        search_query = self._prepare_search_query(
+            tracker, int(self.max_messages_in_query)
+        )
+        tracker_state = tracker.current_state(EventVerbosity.AFTER_RESTART)
 
-        documents = SearchResultList.from_dict(documents_data)
+        try:
+            documents = await self.vector_store.search(
+                query=search_query,
+                tracker_state=tracker_state,
+                threshold=vector_search_threshold,
+            )
+        except InformationRetrievalException as e:
+            logger.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")
             return self._create_prediction_cannot_handle(domain, tracker)
 
-        llm = llm_factory(self.config.get(LLM_CONFIG_KEY), DEFAULT_LLM_CONFIG)
-
         if self.use_llm:
             prompt = self._render_prompt(tracker, documents.results)
             llm_response = await self._generate_llm_answer(llm, prompt)
@@ -414,29 +595,25 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                     result.text for result in documents.results
                 ],
                 UTTER_SOURCE_METADATA_KEY: self.__class__.__name__,
-                SEARCH_QUERY_METADATA_KEY: tracker.latest_message.parse_data.get(
-                    SEARCH_QUERY_KEY
-                ),
+                SEARCH_QUERY_METADATA_KEY: search_query,
             }
         }
 
-        # # telemetry call to track policy prediction
-        # track_enterprise_search_policy_predict(
-        #     vector_store_type=self.vector_store_config.get(
-        #     VECTOR_STORE_TYPE_PROPERTY),
-        #     embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
-        #     embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
-        #     or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
-        #     embeddings_model_group_id=self.embeddings_config.get(
-        #         MODEL_GROUP_ID_CONFIG_KEY
-        #     ),
-        #     llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
-        #     llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
-        #     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,
-        # )
-
+        # telemetry call to track policy prediction
+        track_enterprise_search_policy_predict(
+            vector_store_type=self.vector_store_config.get(VECTOR_STORE_TYPE_PROPERTY),
+            embeddings_type=self.embeddings_config.get(PROVIDER_CONFIG_KEY),
+            embeddings_model=self.embeddings_config.get(MODEL_CONFIG_KEY)
+            or self.embeddings_config.get(MODEL_NAME_CONFIG_KEY),
+            embeddings_model_group_id=self.embeddings_config.get(
+                MODEL_GROUP_ID_CONFIG_KEY
+            ),
+            llm_type=self.llm_config.get(PROVIDER_CONFIG_KEY),
+            llm_model=self.llm_config.get(MODEL_CONFIG_KEY)
+            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,
+        )
         return self._create_prediction(
             domain=domain, tracker=tracker, action_metadata=action_metadata
         )
@@ -604,28 +781,89 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
                 "enterprise_search_policy.load.failed", error=e, resource=resource.name
             )
 
+        store_type = config.get(VECTOR_STORE_PROPERTY, {}).get(
+            VECTOR_STORE_TYPE_PROPERTY
+        )
+
+        embeddings = cls._create_plain_embedder(config)
+
         logger.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
+            # TODO figure out a way to get path without context manager
+            with model_storage.read_from(resource) as path:
+                vector_store = FAISS_Store(
+                    embeddings=embeddings,
+                    index_path=path,
+                    docs_folder=None,
+                    create_index=False,
+                )
+        else:
+            vector_store = create_from_endpoint_config(
+                config_type=store_type,
+                embeddings=embeddings,
+            )  # type: ignore
 
         return cls(
             config,
             model_storage,
             resource,
             execution_context,
+            vector_store=vector_store,
             prompt_template=prompt_template,
         )
 
+    @classmethod
+    def _get_local_knowledge_data(cls, config: Dict[str, Any]) -> Optional[List[str]]:
+        """This is required only for local knowledge base types.
+
+        e.g. FAISS, to ensure that the graph component is retrained when the knowledge
+        base is updated.
+        """
+        merged_config = {**cls.get_default_config(), **config}
+
+        store_type = merged_config.get(VECTOR_STORE_PROPERTY, {}).get(
+            VECTOR_STORE_TYPE_PROPERTY
+        )
+        if store_type != DEFAULT_VECTOR_STORE_TYPE:
+            return None
+
+        source = merged_config.get(VECTOR_STORE_PROPERTY, {}).get(SOURCE_PROPERTY)
+        if not source:
+            return None
+
+        docs = FAISS_Store.load_documents(source)
+
+        if len(docs) == 0:
+            return None
+
+        docs_as_strings = [
+            json.dumps(doc.dict(), ensure_ascii=False, sort_keys=True) for doc in docs
+        ]
+        return sorted(docs_as_strings)
+
     @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,
         )
 
         llm_config = resolve_model_client_config(
             config.get(LLM_CONFIG_KEY), EnterpriseSearchPolicy.__name__
         )
-        return deep_container_fingerprint([prompt_template, llm_config])
+        embedding_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY), EnterpriseSearchPolicy.__name__
+        )
+        return deep_container_fingerprint(
+            [prompt_template, local_knowledge_data, llm_config, embedding_config]
+        )
 
     @staticmethod
     def post_process_citations(llm_answer: str) -> str:
@@ -730,3 +968,14 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             log_source_method,
             EnterpriseSearchPolicy.__name__,
         )
+
+        # Perform health check of the embeddings client config
+        embeddings_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY, {})
+        )
+        cls.perform_embeddings_health_check(
+            embeddings_config,
+            DEFAULT_EMBEDDINGS_CONFIG,
+            log_source_method,
+            EnterpriseSearchPolicy.__name__,
+        )

rasa/core/policies/intentless_policy.py

@@ -58,6 +58,7 @@ from rasa.shared.providers.embedding._langchain_embedding_client_adapter import
     _LangchainEmbeddingClientAdapter,
 )
 from rasa.shared.providers.llm.llm_client import LLMClient
+from rasa.shared.utils.constants import LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON
 from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
     EmbeddingsHealthCheckMixin,
 )
@@ -939,6 +940,8 @@ class IntentlessPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Policy):
         prompt_template = get_prompt_template(
             config.get(PROMPT_CONFIG_KEY),
             DEFAULT_INTENTLESS_PROMPT_TEMPLATE,
+            log_source_component=IntentlessPolicy.__name__,
+            log_source_method=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
         )
 
         llm_config = resolve_model_client_config(

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -35,6 +35,10 @@ from rasa.shared.exceptions import FileIOException, InvalidConfigException
 from rasa.shared.nlu.constants import COMMANDS, TEXT
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.shared.utils.constants import (
+    LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
+    LOG_COMPONENT_SOURCE_METHOD_INIT,
+)
 from rasa.shared.utils.health_check.llm_health_check_mixin import LLMHealthCheckMixin
 from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
@@ -107,6 +111,8 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
             or get_prompt_template(
                 config.get(PROMPT_CONFIG_KEY),
                 DEFAULT_COMMAND_PROMPT_TEMPLATE,
+                log_source_component=LLMBasedRouter.__name__,
+                log_source_method=LOG_COMPONENT_SOURCE_METHOD_INIT,
             ).strip()
         )
 
@@ -318,6 +324,8 @@ class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
         prompt_template = get_prompt_template(
             config.get(PROMPT_CONFIG_KEY),
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
+            log_source_component=LLMBasedRouter.__name__,
+            log_source_method=LOG_COMPONENT_SOURCE_METHOD_FINGERPRINT_ADDON,
         )
 
         llm_config = resolve_model_client_config(

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -65,7 +65,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
         """Converts the command to a DSL string."""
         mapper = {
             CommandSyntaxVersion.v1: "SearchAndReply()",
-            CommandSyntaxVersion.v2: "search and reply",
+            CommandSyntaxVersion.v2: "provide info",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),
@@ -81,7 +81,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
     def regex_pattern() -> str:
         mapper = {
             CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
-            CommandSyntaxVersion.v2: r"""^[\s\W\d]*search and reply['"`]*$""",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*provide info['"`]*$""",
         }
         return mapper.get(
             CommandSyntaxManager.get_syntax_version(),

rasa/dialogue_understanding/generator/command_parser.py

@@ -169,7 +169,7 @@ def _parse_standard_commands(
     commands: List[Command] = []
     for command_clz in standard_commands:
         pattern = _get_compiled_pattern(command_clz.regex_pattern())
-        if match := pattern.search(action.strip()):
+        if match := pattern.search(action):
             parsed_command = command_clz.from_dsl(match, **kwargs)
             if _additional_parsing_fn := _get_additional_parsing_logic(command_clz):
                 parsed_command = _additional_parsing_fn(parsed_command, flows, **kwargs)

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -52,7 +52,6 @@ from rasa.shared.utils.llm import (
     USER,
     allowed_values_for_slot,
     embedder_factory,
-    get_prompt_template,
     resolve_model_client_config,
     tracker_as_readable_transcript,
 )
@@ -103,9 +102,7 @@ class FlowRetrieval(EmbeddingsHealthCheckMixin):
             self.config.get(EMBEDDINGS_CONFIG_KEY), FlowRetrieval.__name__
         )
         self.vector_store: Optional[FAISS] = None
-        self.flow_document_template = get_prompt_template(
-            None, DEFAULT_FLOW_DOCUMENT_TEMPLATE
-        )
+        self.flow_document_template = DEFAULT_FLOW_DOCUMENT_TEMPLATE
         self._model_storage = model_storage
         self._resource = resource
 

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -390,8 +390,7 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-
-        return sorted(result, key=lambda x: x["name"])
+        return result
 
     @staticmethod
     def is_extractable(