rasa-pro 3.10.16__py3-none-any.whl → 3.11.0__py3-none-any.whl

rasa/core/utils.py

@@ -1,8 +1,9 @@
+import structlog
 import logging
 import os
 from pathlib import Path
 from socket import SOCK_DGRAM, SOCK_STREAM
-from typing import Any, Dict, Optional, Set, TYPE_CHECKING, Text, Tuple, Union
+from typing import Any, Dict, Optional, List, Set, TYPE_CHECKING, Text, Tuple, Union
 
 import numpy as np
 from sanic import Sanic
@@ -19,14 +20,18 @@ from rasa.core.constants import (
 from rasa.core.lock_store import LockStore, RedisLockStore, InMemoryLockStore
 from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH, TCP_PROTOCOL
 from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.utils.endpoints import EndpointConfig, read_endpoint_config
+from rasa.utils.endpoints import (
+    EndpointConfig,
+    read_endpoint_config,
+    read_property_config_from_endpoints_file,
+)
 from rasa.utils.io import write_yaml
 
 if TYPE_CHECKING:
     from rasa.core.nlg import NaturalLanguageGenerator
     from rasa.shared.core.domain import Domain
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger()
 
 
 def configure_file_logging(
@@ -124,15 +129,17 @@ def list_routes(app: Sanic) -> Dict[Text, Text]:
         for arg in route._params:
             options[arg] = f"[{arg}]"
 
-        handlers = [(next(iter(route.methods)), route.name.replace("rasa_server.", ""))]
+        name = route.name.replace("rasa_server.", "")
+        methods = ",".join(route.methods)
 
-        for method, name in handlers:
-            full_endpoint = "/" + "/".join(endpoint)
-            line = unquote(f"{full_endpoint:50s} {method:30s} {name}")
-            output[name] = line
+        full_endpoint = "/" + "/".join(endpoint)
+        line = unquote(f"{full_endpoint:50s} {methods:30s} {name}")
+        output[name] = line
 
     url_table = "\n".join(output[url] for url in sorted(output))
-    logger.debug(f"Available web server routes: \n{url_table}")
+    structlogger.debug(
+        "server.routes", event_info=f"Available web server routes: \n{url_table}"
+    )
 
     return output
 
@@ -186,6 +193,9 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        model_groups = read_property_config_from_endpoints_file(
+            endpoint_file, property_name="model_groups"
+        )
 
         return cls(
             nlg,
@@ -196,6 +206,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            model_groups,
         )
 
     def __init__(
@@ -208,6 +219,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        model_groups: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         """Create an `AvailableEndpoints` object."""
         self.model = model
@@ -218,6 +230,7 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.model_groups = model_groups
 
     @classmethod
     def get_instance(cls, endpoint_file: Optional[Text] = None) -> "AvailableEndpoints":
@@ -273,17 +286,22 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
     """
 
     def _log_and_get_default_number_of_workers() -> int:
-        logger.debug(
-            f"Using the default number of Sanic workers ({DEFAULT_SANIC_WORKERS})."
+        structlogger.debug(
+            "server.worker.set_count",
+            number_of_workers=DEFAULT_SANIC_WORKERS,
+            event_info=f"Using the default number of Sanic workers "
+            f"({DEFAULT_SANIC_WORKERS}).",
         )
         return DEFAULT_SANIC_WORKERS
 
     try:
         env_value = int(os.environ.get(ENV_SANIC_WORKERS, DEFAULT_SANIC_WORKERS))
     except ValueError:
-        logger.error(
-            f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
-            f"to int ('{os.environ[ENV_SANIC_WORKERS]}')."
+        structlogger.error(
+            "server.worker.set_count.error",
+            number_of_workers=os.environ[ENV_SANIC_WORKERS],
+            event_info=f"Cannot convert environment variable `{ENV_SANIC_WORKERS}` "
+            f"to int ('{os.environ[ENV_SANIC_WORKERS]}').",
         )
         return _log_and_get_default_number_of_workers()
 
@@ -291,20 +309,28 @@ def number_of_sanic_workers(lock_store: Union[EndpointConfig, LockStore, None])
         return _log_and_get_default_number_of_workers()
 
     if env_value < 1:
-        logger.debug(
-            f"Cannot set number of Sanic workers to the desired value "
-            f"({env_value}). The number of workers must be at least 1."
+        structlogger.warning(
+            "server.worker.set_count.error_less_than_one",
+            number_of_workers=env_value,
+            event_info=f"Cannot set number of Sanic workers to the desired value "
+            f"({env_value}). The number of workers must be at least 1.",
         )
         return _log_and_get_default_number_of_workers()
 
     if _lock_store_is_multi_worker_compatible(lock_store):
-        logger.debug(f"Using {env_value} Sanic workers.")
+        structlogger.debug(
+            "server.worker.set_count.success",
+            event_info=f"Using {env_value} Sanic workers.",
+            num_workers=env_value,
+        )
         return env_value
 
-    logger.debug(
-        f"Unable to assign desired number of Sanic workers ({env_value}) as "
+    structlogger.warning(
+        "server.worker.set_count.error_no_lock_store",
+        event_info=f"Unable to assign desired number of Sanic workers ({env_value}) as "
         f"no `RedisLockStore` or custom `LockStore` endpoint "
-        f"configuration has been found."
+        f"configuration has been found.",
+        num_workers=env_value,
     )
     return _log_and_get_default_number_of_workers()
 

rasa/dialogue_understanding/coexistence/llm_based_router.py

@@ -15,7 +15,9 @@ from rasa.dialogue_understanding.coexistence.constants import (
 )
 from rasa.dialogue_understanding.commands import Command, SetSlotCommand
 from rasa.dialogue_understanding.commands.noop_command import NoopCommand
-from rasa.dialogue_understanding.generator.constants import LLM_CONFIG_KEY
+from rasa.dialogue_understanding.generator.constants import (
+    LLM_CONFIG_KEY,
+)
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
@@ -33,11 +35,13 @@ from rasa.shared.exceptions import InvalidConfigException, FileIOException
 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.health_check.llm_health_check_mixin import LLMHealthCheckMixin
+from rasa.shared.utils.io import deep_container_fingerprint
 from rasa.shared.utils.llm import (
     DEFAULT_OPENAI_CHAT_MODEL_NAME,
     get_prompt_template,
     llm_factory,
-    try_instantiate_llm_client,
+    resolve_model_client_config,
 )
 from rasa.utils.log_utils import log_llm
 
@@ -45,6 +49,7 @@ LLM_BASED_ROUTER_PROMPT_FILE_NAME = "llm_based_router_prompt.jinja2"
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.coexistence", "router_template.jinja2"
 )
+LLM_BASED_ROUTER_CONFIG_FILE_NAME = "config.json"
 
 # Token ids for gpt 3.5 and gpt 4 corresponding to space + capitalized Letter
 A_TO_C_TOKEN_IDS_CHATGPT = [
@@ -71,7 +76,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class LLMBasedRouter(GraphComponent):
+class LLMBasedRouter(LLMHealthCheckMixin, GraphComponent):
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
@@ -93,6 +98,9 @@ class LLMBasedRouter(GraphComponent):
         prompt_template: Optional[str] = None,
     ) -> None:
         self.config = {**self.get_default_config(), **config}
+        self.config[LLM_CONFIG_KEY] = resolve_model_client_config(
+            self.config.get(LLM_CONFIG_KEY), LLMBasedRouter.__name__
+        )
 
         self.prompt_template = (
             prompt_template
@@ -126,15 +134,17 @@ class LLMBasedRouter(GraphComponent):
             rasa.shared.utils.io.write_text_file(
                 self.prompt_template, path / LLM_BASED_ROUTER_PROMPT_FILE_NAME
             )
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                path / LLM_BASED_ROUTER_CONFIG_FILE_NAME, self.config
+            )
 
     def train(self, training_data: TrainingData) -> Resource:
         """Train the intent classifier on a data set."""
-        # Validate llm configuration
-        try_instantiate_llm_client(
+        self.perform_llm_health_check(
             self.config.get(LLM_CONFIG_KEY),
             DEFAULT_LLM_CONFIG,
             "llm_based_router.train",
-            "LLMBasedRouter",
+            LLMBasedRouter.__name__,
         )
 
         self.persist()
@@ -150,6 +160,16 @@ class LLMBasedRouter(GraphComponent):
         **kwargs: Any,
     ) -> "LLMBasedRouter":
         """Loads trained component (see parent class for full docstring)."""
+
+        # Perform health check on the resolved LLM client config
+        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
+        cls.perform_llm_health_check(
+            llm_config,
+            DEFAULT_LLM_CONFIG,
+            "llm_based_router.load",
+            LLMBasedRouter.__name__,
+        )
+
         prompt_template = None
         try:
             with model_storage.read_from(resource) as path:
@@ -161,14 +181,7 @@ class LLMBasedRouter(GraphComponent):
                 "llm_based_router.load.failed", error=e, resource=resource.name
             )
 
-        router = cls(config, model_storage, resource, prompt_template=prompt_template)
-        try_instantiate_llm_client(
-            router.config.get(LLM_CONFIG_KEY),
-            DEFAULT_LLM_CONFIG,
-            "llm_based_router.load",
-            LLMBasedRouter.__name__,
-        )
-        return router
+        return cls(config, model_storage, resource, prompt_template=prompt_template)
 
     @classmethod
     def create(
@@ -298,3 +311,17 @@ class LLMBasedRouter(GraphComponent):
             # we have to catch all exceptions here
             structlogger.error("llm_based_router.llm.error", error=e)
             return None
+
+    @classmethod
+    def fingerprint_addon(cls, config: Dict[str, Any]) -> Optional[str]:
+        """Add a fingerprint of llm based router for the graph."""
+        prompt_template = get_prompt_template(
+            config.get(PROMPT_CONFIG_KEY),
+            DEFAULT_COMMAND_PROMPT_TEMPLATE,
+        )
+
+        llm_config = resolve_model_client_config(
+            config.get(LLM_CONFIG_KEY), LLMBasedRouter.__name__
+        )
+
+        return deep_container_fingerprint([prompt_template, llm_config])

rasa/dialogue_understanding/commands/__init__.py

@@ -32,6 +32,10 @@ from rasa.dialogue_understanding.commands.change_flow_command import ChangeFlowC
 from rasa.dialogue_understanding.commands.session_start_command import (
     SessionStartCommand,
 )
+from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
+from rasa.dialogue_understanding.commands.repeat_bot_messages_command import (
+    RepeatBotMessagesCommand,
+)
 
 __all__ = [
     "Command",
@@ -51,5 +55,7 @@ __all__ = [
     "NoopCommand",
     "ChangeFlowCommand",
     "SessionStartCommand",
+    "SessionEndCommand",
+    "RepeatBotMessagesCommand",
     "RestartCommand",
 ]

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.repeat import (
+    RepeatBotMessagesPatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RepeatBotMessagesCommand(Command):
+    """A command to indicate that the bot should repeat its last messages."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "repeat"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RepeatBotMessagesCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return RepeatBotMessagesCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+        Get all the bot utterances until last user utterance and repeat them.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(RepeatBotMessagesPatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, RepeatBotMessagesCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/session_end_command.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.shared.core.events import Event, SessionEnded
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class SessionEndCommand(Command):
+    """A command to indicate the end of a session."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "session end"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> SessionEndCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return SessionEndCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        metadata = {"_reason": "user disconnected"}
+
+        # Add metadata sent by the channel connector, if available
+        if tracker.latest_message:
+            user_metadata = tracker.latest_message.metadata or {}
+            metadata.update(user_metadata)
+
+        return [SessionEnded(metadata=metadata)]
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, SessionEndCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/user_silence_command.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class UserSilenceCommand(Command):
+    """A command to indicate user silence."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "user silence"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> UserSilenceCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return UserSilenceCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        stack.push(UserSilencePatternFlowStackFrame())
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, UserSilenceCommand):
+            return False
+
+        return True

rasa/dialogue_understanding/commands/utils.py

@@ -11,6 +11,7 @@ from rasa.dialogue_understanding.commands import (
     SkipQuestionCommand,
     RestartCommand,
 )
+from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
 from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
 from rasa.dialogue_understanding.patterns.cannot_handle import (
     CannotHandlePatternFlowStackFrame,
@@ -27,9 +28,13 @@ from rasa.dialogue_understanding.patterns.session_start import (
 from rasa.dialogue_understanding.patterns.skip_question import (
     SkipQuestionPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.user_silence import (
+    UserSilencePatternFlowStackFrame,
+)
 
 triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
     SessionStartPatternFlowStackFrame.flow_id: SessionStartCommand,
+    UserSilencePatternFlowStackFrame.flow_id: UserSilenceCommand,
     CancelPatternFlowStackFrame.flow_id: CancelFlowCommand,
     ChitchatPatternFlowStackFrame.flow_id: ChitChatAnswerCommand,
     HumanHandoffPatternFlowStackFrame.flow_id: HumanHandoffCommand,

rasa/dialogue_understanding/generator/constants.py

@@ -23,3 +23,5 @@ USER_INPUT_CONFIG_KEY = "user_input"
 FLOW_RETRIEVAL_KEY = "flow_retrieval"
 FLOW_RETRIEVAL_ACTIVE_KEY = "active"
 FLOW_RETRIEVAL_EMBEDDINGS_CONFIG_KEY = "embeddings"
+
+FLOW_RETRIEVAL_FLOW_THRESHOLD = 20

rasa/dialogue_understanding/generator/flow_retrieval.py

@@ -1,5 +1,4 @@
-"""
-The module is primarily centered around the `FlowRetrieval` class which handles the
+"""The module is primarily centered around the `FlowRetrieval` class which handles the
 initialization, configuration validation, vector store management, and flow retrieval
 logic. It integrates components for managing embeddings, vector stores, and
 flow-specific templates, facilitating semantic search functionalities.
@@ -27,8 +26,10 @@ from langchain.docstore.document import Document
 from langchain.schema.embeddings import Embeddings
 from langchain_community.vectorstores.faiss import FAISS
 from langchain_community.vectorstores.utils import DistanceStrategy
+
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+import rasa.shared.utils.io
 from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     PROVIDER_CONFIG_KEY,
@@ -37,12 +38,15 @@ from rasa.shared.constants import (
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.exceptions import ProviderClientAPIException
 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.providers.embedding._langchain_embedding_client_adapter import (
     _LangchainEmbeddingClientAdapter,
 )
+from rasa.shared.utils.health_check.embeddings_health_check_mixin import (
+    EmbeddingsHealthCheckMixin,
+)
 from rasa.shared.utils.llm import (
     tracker_as_readable_transcript,
     embedder_factory,
@@ -50,13 +54,15 @@ from rasa.shared.utils.llm import (
     USER,
     get_prompt_template,
     allowed_values_for_slot,
-    try_instantiate_embedder,
+    resolve_model_client_config,
 )
 
 DEFAULT_FLOW_DOCUMENT_TEMPLATE = importlib.resources.read_text(
     "rasa.dialogue_understanding.generator", "flow_document_template.jinja2"
 )
 
+FLOW_RETRIEVAL_CONFIG_FILE_NAME = "flow_retrieval_config.json"
+
 DEFAULT_EMBEDDINGS_CONFIG = {
     PROVIDER_CONFIG_KEY: OPENAI_PROVIDER,
     "model": DEFAULT_OPENAI_EMBEDDING_MODEL_NAME,
@@ -74,7 +80,7 @@ DEFAULT_SHOULD_EMBED_SLOTS = True
 structlogger = structlog.get_logger()
 
 
-class FlowRetrieval:
+class FlowRetrieval(EmbeddingsHealthCheckMixin):
     @classmethod
     def get_default_config(cls) -> Dict[str, Any]:
         """The default config for the flow retrieval."""
@@ -93,6 +99,9 @@ class FlowRetrieval:
     ):
         config = {**self.get_default_config(), **config}
         self.config = self.validate_config(config)
+        self.config[EMBEDDINGS_CONFIG_KEY] = resolve_model_client_config(
+            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
@@ -141,19 +150,26 @@ class FlowRetrieval:
         **kwargs: Any,
     ) -> "FlowRetrieval":
         """Load flow retrieval with previously populated FAISS vector store."""
-        # initialize base flow retrieval
-        flow_retrieval = FlowRetrieval(config, model_storage, resource)
-        try_instantiate_embedder(
-            flow_retrieval.config.get(EMBEDDINGS_CONFIG_KEY),
+
+        # Perform health check on resolved embedding client config
+        embeddings_config = resolve_model_client_config(
+            config.get(EMBEDDINGS_CONFIG_KEY, {})
+        )
+        cls.perform_embeddings_health_check(
+            embeddings_config,
             DEFAULT_EMBEDDINGS_CONFIG,
             "flow_retrieval.load",
             FlowRetrieval.__name__,
         )
+
+        # initialize base flow retrieval
+        flow_retrieval = FlowRetrieval(config, model_storage, resource)
         # load vector store
         vector_store = cls._load_vector_store(
             flow_retrieval.config, model_storage, resource
         )
         flow_retrieval.vector_store = vector_store
+
         return flow_retrieval
 
     @classmethod
@@ -185,13 +201,21 @@ class FlowRetrieval:
         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), FlowRetrieval.__name__
+        )
         client = embedder_factory(
             config.get(EMBEDDINGS_CONFIG_KEY), DEFAULT_EMBEDDINGS_CONFIG
         )
+        # Wrap the embedding client in the adapter
         return _LangchainEmbeddingClientAdapter(client)
 
     def persist(self) -> None:
         self._persist_vector_store()
+        self._persist_config()
 
     def _persist_vector_store(self) -> None:
         """Persists the FAISS vector store."""
@@ -204,6 +228,12 @@ class FlowRetrieval:
                 event_info="Vector store is None, not persisted.",
             )
 
+    def _persist_config(self) -> None:
+        with self._model_storage.write_to(self._resource) as path:
+            rasa.shared.utils.io.dump_obj_as_json_to_file(
+                path / FLOW_RETRIEVAL_CONFIG_FILE_NAME, self.config
+            )
+
     def populate(self, flows: FlowsList, domain: Domain) -> None:
         """Populates the vector store with embeddings generated from
         documents based on the flow descriptions, and flow slots
@@ -213,6 +243,14 @@ class FlowRetrieval:
             flows: List of flows to populate the vector store with.
             domain: The domain containing relevant slot information.
         """
+        # Perform health check before populating the vector store with flows
+        self.perform_embeddings_health_check(
+            self.config.get(EMBEDDINGS_CONFIG_KEY),
+            DEFAULT_EMBEDDINGS_CONFIG,
+            "flow_retrieval.train",
+            FlowRetrieval.__name__,
+        )
+
         flows_to_embedd = flows.exclude_link_only_flows()
         embeddings = self._create_embedder(self.config)
         documents = self._generate_flow_documents(flows_to_embedd, domain)