rasa-pro 3.11.0a4.dev3__py3-none-any.whl → 3.11.0rc2__py3-none-any.whl

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -4,6 +4,11 @@ responses:
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
+  utter_ask_still_there:
+    - text: "Hello, are you still there?"
+      metadata:
+        rephrase: True
+
   utter_boolean_slot_rejection:
     - text: "Sorry, the value you provided, `{{value}}`, is not valid. Please respond with a valid value."
       metadata:
@@ -75,6 +80,11 @@ responses:
       metadata:
         rephrase: True
 
+  utter_inform_hangup:
+    - text: It seems you are not there anymore. I will hang up shortly.
+      metadata:
+        rephrase: True
+
   utter_internal_error_rasa:
     - text: Sorry, I am having trouble with that. Please try again in a few minutes.
 
@@ -251,3 +261,32 @@ flows:
     name: pattern skip question
     steps:
       - action: utter_skip_question_answer
+
+  pattern_user_silence:
+    description: Reacting to user silence in voice bots
+    name: pattern react to silence
+    nlu_trigger:
+      - intent: silence_timeout
+    persisted_slots:
+      - consecutive_silence_timeouts
+    steps:
+      - noop: true
+        next:
+          - if: "slots.consecutive_silence_timeouts = 0.0"
+            then:
+              - set_slots:
+                  - consecutive_silence_timeouts: 1.0
+              - action: action_repeat_bot_messages
+                next: END
+          - if: "slots.consecutive_silence_timeouts = 1.0"
+            then:
+              - set_slots:
+                  - consecutive_silence_timeouts: 2.0
+              - action: utter_ask_still_there
+                next: END
+          - if: "slots.consecutive_silence_timeouts > 1.0"
+            then:
+              - action: utter_inform_hangup
+              - action: action_hangup
+                next: END
+          - else: END

rasa/dialogue_understanding/patterns/user_silence.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_USER_SILENCE = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "user_silence"
+
+
+@dataclass
+class UserSilencePatternFlowStackFrame(PatternFlowStackFrame):
+    """A flow stack frame that can get added when the silence timeout trips."""
+
+    flow_id: str = FLOW_PATTERN_USER_SILENCE
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_USER_SILENCE
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> UserSilencePatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return UserSilencePatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/processor/command_processor.py

@@ -8,6 +8,7 @@ from rasa.dialogue_understanding.commands import (
     Command,
     CorrectSlotsCommand,
     CorrectedSlot,
+    RepeatBotMessagesCommand,
     SetSlotCommand,
     StartFlowCommand,
     FreeFormAnswerCommand,
@@ -422,6 +423,9 @@ def clean_up_commands(
     elif not tracker.has_coexistence_routing_slot and len(clean_commands) > 1:
         clean_commands = filter_cannot_handle_command_for_skipped_slots(clean_commands)
 
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, RepeatBotMessagesCommand, 1
+    )
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
@@ -430,6 +434,22 @@ def clean_up_commands(
     return clean_commands
 
 
+def ensure_max_number_of_command_type(
+    commands: List[Command], command_type: Type[Command], n: int
+) -> List[Command]:
+    """Ensures that for a given command type only the first n stay in the list."""
+    filtered: List[Command] = []
+    count = 0
+    for c in commands:
+        if isinstance(c, command_type):
+            if count >= n:
+                continue
+            else:
+                count += 1
+        filtered.append(c)
+    return filtered
+
+
 def clean_up_clarify_command(
     commands_so_far: List[Command],
     all_commands: List[Command],
@@ -452,7 +472,7 @@ def clean_up_clarify_command(
         if not (isinstance(c, SetSlotCommand) and c.name == ROUTE_TO_CALM_SLOT)
     ]
 
-    # if there are multiple clarify commands, do add the first one
+    # if all commands are clarify commands, add the first one only, otherwise add none
     if all(
         isinstance(c, ClarifyCommand) for c in commands_without_route_to_calm_set_slot
     ):

rasa/e2e_test/e2e_test_case.py

@@ -1,8 +1,10 @@
-import logging
 from collections import OrderedDict
+from collections import defaultdict
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Text, Union
 
+import structlog
+
 from rasa.e2e_test.assertions import Assertion
 from rasa.e2e_test.constants import (
     KEY_ASSERTIONS,
@@ -20,10 +22,11 @@ from rasa.e2e_test.constants import (
     KEY_USER_INPUT,
 )
 from rasa.e2e_test.stub_custom_action import StubCustomAction
+from rasa.shared.constants import DOCS_BASE_URL
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.exceptions import RasaException
 
-logger = logging.getLogger(__name__)
+structlogger = structlog.get_logger(__name__)
 
 
 @dataclass(frozen=True)
@@ -343,9 +346,10 @@ class ActualStepOutput:
             try:
                 return self.user_uttered_events[0]
             except IndexError:
-                logger.debug(
-                    f"Could not find `UserUttered` event in the ActualStepOutput: "
-                    f"{self}"
+                structlogger.debug(
+                    "e2e_test_case.get_user_uttered_event.no_user_uttered_event",
+                    event_info=f"Could not find `UserUttered` event in the "
+                    f"ActualStepOutput: {self}",
                 )
                 return None
         return None
@@ -395,7 +399,7 @@ class TestCase:
             else:
                 steps.append(TestStep.from_dict(step))
 
-        return TestCase(
+        test_case = TestCase(
             name=input_test_case.get(KEY_TEST_CASE, "default"),
             steps=steps,
             file=file,
@@ -405,6 +409,81 @@ class TestCase:
             fixture_names=input_test_case.get(KEY_FIXTURES),
             metadata_name=input_test_case.get(KEY_METADATA),
         )
+        test_case.validate()
+        return test_case
+
+    def validate(self) -> None:
+        """Validates the test case.
+
+        This method calls all validation methods required for the test case.
+        """
+        if self.uses_assertions():
+            self.validate_duplicate_user_messages_metadata()
+
+    def validate_duplicate_user_messages_metadata(self) -> None:
+        """Validates that duplicate user messages use metadata correctly.
+
+        Ensures that each duplicate user message uses unique metadata.
+
+        Raises warnings if any issues are found.
+        """
+        docs_link = (
+            f"{DOCS_BASE_URL}/testing/e2e-testing-assertions/assertions-how-to-guide/"
+            "#how-to-handle-duplicate-user-text-messages-in-the-same-test-case"
+        )
+        no_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} lacks metadata. When using "
+            "duplicate user messages, metadata should be set on each step to ensure "
+            f"correct processing. Please refer to the documentation: {docs_link}"
+        )
+        non_unique_metadata_event_info = (
+            "Test case '{name}' has duplicate user steps with text '{text}', "
+            "and user step at line {line} has duplicate metadata "
+            "name '{metadata_name}'. Metadata names should be unique for each user "
+            "step among duplicates. This may cause issues in processing "
+            f"user messages. Please refer to the documentation: {docs_link}"
+        )
+
+        # Use dict[str, list] structure to group steps by user message text to easily
+        # identify and validate instances with duplicate messages and their metadata.
+        message_steps = defaultdict(list)
+
+        # Collect user steps by text
+        for step in self.steps:
+            if step.actor == KEY_USER_INPUT and step.text:
+                message_steps[step.text].append(step)
+
+        # Check for duplicate messages
+        for text, steps in message_steps.items():
+            if len(steps) <= 1:
+                continue
+
+            metadata_names_used = set()
+            for step in steps:
+                if not step.metadata_name:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.no_metadata",
+                        event_info=no_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                        ),
+                    )
+                    break
+                elif step.metadata_name in metadata_names_used:
+                    structlogger.warning(
+                        "e2e_test_case.validate_duplicate_user_messages_metadata.non_unique_metadata",
+                        event_info=non_unique_metadata_event_info.format(
+                            name=self.name,
+                            text=text,
+                            line=step.line,
+                            metadata_name=step.metadata_name,
+                        ),
+                    )
+                    break
+                else:
+                    metadata_names_used.add(step.metadata_name)
 
     def as_dict(self) -> Dict[Text, Any]:
         """Returns the test case as a dictionary."""

rasa/e2e_test/e2e_test_runner.py

@@ -190,11 +190,11 @@ class E2ETestRunner:
                     error=f"Message handling timed out for user message '{step.text}'.",
                     exc_info=True,
                 )
-            except Exception:
+            except Exception as exc:
                 structlogger.error(
                     "e2e_test_runner.run_prediction_loop",
                     error=f"An exception occurred while handling "
-                    f"user message '{step.text}'.",
+                    f"user message '{step.text}'. Error: {exc}",
                 )
             tracker = await self.agent.tracker_store.retrieve(sender_id)  # type: ignore[assignment]
             turns[position], event_cursor = self.get_actual_step_output(
@@ -1155,6 +1155,8 @@ class E2ETestRunner:
                     flow_paths_stack
                     and self.agent.domain
                     and self.agent.domain.is_custom_action(event.action_name)
+                    and STEP_ID_METADATA_KEY in event.metadata
+                    and ACTIVE_FLOW_METADATA_KEY in event.metadata
                 ):
                     flow_paths_stack[-1].nodes.append(self._create_path_node(event))
 

rasa/e2e_test/utils/io.py

@@ -346,7 +346,7 @@ def read_test_cases(path: str) -> TestSuite:
     beta_flag_verified = False
 
     for test_file in test_files:
-        test_file_content = parse_raw_yaml(Path(test_file).read_text())
+        test_file_content = parse_raw_yaml(Path(test_file).read_text(encoding="utf-8"))
 
         validate_yaml_data_using_schema_with_assertions(
             yaml_data=test_file_content, schema_content=e2e_test_schema

rasa/engine/validation.py

@@ -1,7 +1,7 @@
 import dataclasses
 import inspect
-import re
 import logging
+import re
 import sys
 import typing
 from typing import (
@@ -18,11 +18,10 @@ from typing import (
     List,
 )
 
+import rasa.utils.common
 import structlog
 import typing_utils
-
-import rasa.utils.common
-from rasa.core import IntentlessPolicy
+from rasa.core import IntentlessPolicy, ContextualResponseRephraser
 from rasa.core.policies.policy import PolicyPrediction
 from rasa.core.utils import AvailableEndpoints
 from rasa.dialogue_understanding.coexistence.constants import (
@@ -31,9 +30,17 @@ from rasa.dialogue_understanding.coexistence.constants import (
     STICKY,
     NON_STICKY,
 )
+from rasa.dialogue_understanding.coexistence.intent_based_router import (
+    IntentBasedRouter,
+)
+from rasa.dialogue_understanding.coexistence.llm_based_router import LLMBasedRouter
 from rasa.dialogue_understanding.generator import (
     LLMBasedCommandGenerator,
 )
+from rasa.dialogue_understanding.generator.constants import (
+    LLM_CONFIG_KEY,
+    FLOW_RETRIEVAL_KEY,
+)
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.engine.constants import RESERVED_PLACEHOLDERS
 from rasa.engine.exceptions import GraphSchemaValidationException
@@ -47,18 +54,32 @@ from rasa.engine.graph import (
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
 from rasa.engine.training.fingerprinting import Fingerprintable
-from rasa.shared.constants import DOCS_URL_GRAPH_COMPONENTS, ROUTE_TO_CALM_SLOT
+from rasa.shared.constants import (
+    DOCS_URL_GRAPH_COMPONENTS,
+    ROUTE_TO_CALM_SLOT,
+    EMBEDDINGS_CONFIG_KEY,
+    API_BASE_CONFIG_KEY,
+    DEPLOYMENT_CONFIG_KEY,
+    API_VERSION_CONFIG_KEY,
+    API_KEY,
+    AWS_REGION_NAME_CONFIG_KEY,
+    MODEL_GROUP_ID_CONFIG_KEY,
+    ROUTER_CONFIG_KEY,
+    MODELS_CONFIG_KEY,
+    MODEL_GROUP_CONFIG_KEY,
+    ROUTER_STRATEGY_CONFIG_KEY,
+    VALID_ROUTER_STRATEGIES,
+    ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE,
+    ROUTER_STRATEGIES_NOT_REQUIRING_CACHE,
+    REDIS_HOST_CONFIG_KEY,
+)
 from rasa.shared.core.constants import ACTION_RESET_ROUTING, ACTION_TRIGGER_CHITCHAT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList, Flow
 from rasa.shared.core.slots import Slot
 from rasa.shared.exceptions import RasaException
 from rasa.shared.nlu.training_data.message import Message
-
-from rasa.dialogue_understanding.coexistence.intent_based_router import (
-    IntentBasedRouter,
-)
-from rasa.dialogue_understanding.coexistence.llm_based_router import LLMBasedRouter
+from rasa.shared.utils.cli import print_error_and_exit
 
 TypeAnnotation = Union[TypeVar, Text, Type, Optional[AvailableEndpoints]]
 
@@ -845,6 +866,291 @@ def validate_coexistance_routing_setup(
     )
 
 
+def _validate_component_model_client_config(
+    component_config: Dict[str, Any],
+    key: str,
+    model_group_syntax_used: List[bool],
+    model_group_ids: List[str],
+    component_name: Optional[str] = None,
+) -> None:
+    """Validate the LLM configuration of a component.
+
+    Checks if the llm is defined using the new syntax or the old syntax.
+    If the new syntax is used, it checks that no other parameters are present.
+
+    Args:
+        component_config: The config of the component
+        key: either 'llm' or 'embeddings'
+        model_group_syntax_used:
+            list of booleans indicating whether the new syntax is used
+        model_group_ids: list of model group ids
+        component_name: the name of the component
+    """
+    if key not in component_config:
+        # no llm configuration present
+        return
+
+    if MODEL_GROUP_CONFIG_KEY in component_config[key]:
+        model_group_syntax_used.append(True)
+        model_group_ids.append(component_config[key][MODEL_GROUP_CONFIG_KEY])
+
+        if len(component_config[key]) > 1:
+            print_error_and_exit(
+                f"You specified a '{MODEL_GROUP_CONFIG_KEY}' for the '{key}' "
+                f"config key for the component "
+                f"'{component_name or component_config['name']}'. "
+                "No other parameters are allowed under the "
+                f"'{key}' key in that case. Please update your config."
+            )
+    else:
+        model_group_syntax_used.append(False)
+
+        # check that api_key is not set in config
+        if API_KEY in component_config[key]:
+            print_error_and_exit(
+                f"You specified '{API_KEY}' in the config for "
+                f"'{component_name or component_config['name']}', which is not allowed."
+                " Set API keys through environment variables."
+            )
+
+
+def validate_model_client_configuration_setup(config: Dict[str, Any]) -> None:
+    """Validates the model client configuration setup.
+
+    Checks the model configuration of the components in the pipeline.
+    Validation fails, if
+    - the LLM/embeddings is/are defined using the old and the new syntax at
+      the same time (either at component level itself or across different components)
+    - the LLM/embeddings is/are defined using the new syntax, but no model
+      group is defined or the referenced model group does not exist
+
+    Args:
+        config: The config dictionary
+    """
+
+    def is_uniform_bool_list(bool_list: List[bool]) -> bool:
+        # check if list contains only True or False
+        return all(bool_list) or not any(bool_list)
+
+    model_group_syntax_used: List[bool] = []
+    model_group_ids: List[str] = []
+
+    for outer_key in ["pipeline", "policies"]:
+        if outer_key not in config or config[outer_key] is None:
+            continue
+
+        for component in config[outer_key]:
+            for key in [LLM_CONFIG_KEY, EMBEDDINGS_CONFIG_KEY]:
+                _validate_component_model_client_config(
+                    component, key, model_group_syntax_used, model_group_ids
+                )
+
+            # as flow retrieval is not a component itself, we need to
+            # check it separately
+            if FLOW_RETRIEVAL_KEY in component:
+                if EMBEDDINGS_CONFIG_KEY in component[FLOW_RETRIEVAL_KEY]:
+                    _validate_component_model_client_config(
+                        component[FLOW_RETRIEVAL_KEY],
+                        EMBEDDINGS_CONFIG_KEY,
+                        model_group_syntax_used,
+                        model_group_ids,
+                        component["name"] + "." + FLOW_RETRIEVAL_KEY,
+                    )
+
+    # also include the ContextualResponseRephraser component
+    endpoints = AvailableEndpoints.get_instance()
+    if endpoints.nlg is not None:
+        _validate_component_model_client_config(
+            endpoints.nlg.kwargs,
+            LLM_CONFIG_KEY,
+            model_group_syntax_used,
+            model_group_ids,
+            ContextualResponseRephraser.__name__,
+        )
+
+    if not is_uniform_bool_list(model_group_syntax_used):
+        print_error_and_exit(
+            "Some of your components refer to an LLM using the "
+            f"'{MODEL_GROUP_CONFIG_KEY}' parameter, other components directly"
+            f" define the LLM under the '{LLM_CONFIG_KEY}' or the "
+            f"'{EMBEDDINGS_CONFIG_KEY}' key. You cannot use"
+            " both types of definitions. Please chose one syntax "
+            "and update your config."
+        )
+
+    # Print a deprecation warning in case the old syntax is used.
+    if len(model_group_syntax_used) > 0 and model_group_syntax_used[0] is False:
+        structlogger.warning(
+            "validate_llm_configuration_setup",
+            event_info=(
+                "Defining the LLM configuration in the config.yml file itself is"
+                " deprecated and will be removed in Rasa 4.0.0. "
+                "Please use the new syntax and define your LLM configuration"
+                "in the endpoints.yml file."
+            ),
+        )
+
+    endpoints = AvailableEndpoints.get_instance()
+    if len(model_group_ids) > 0 and endpoints.model_groups is None:
+        print_error_and_exit(
+            "You are referring to (a) model group(s) in your "
+            "config.yml file, but no model group was defined in "
+            "the endpoints.yml file. Please define the model "
+            "group(s)."
+        )
+
+    if endpoints.model_groups is None:
+        return
+
+    existing_model_group_ids = [
+        model_group[MODEL_GROUP_ID_CONFIG_KEY] for model_group in endpoints.model_groups
+    ]
+
+    for model_group_id in model_group_ids:
+        if model_group_id not in existing_model_group_ids:
+            print_error_and_exit(
+                "One of your components is referring to the model group "
+                f"'{model_group_id}', but this model group does not exist in the "
+                f"endpoints.yml file. Please chose one of the existing "
+                f"model groups ({existing_model_group_ids}) or define "
+                f"the a model group for '{model_group_id}'."
+            )
+
+
+def _validate_unique_model_group_ids(model_groups: List[Dict[str, Any]]) -> None:
+    # Each model id must be unique within the model_groups
+    model_ids = [model_group[MODEL_GROUP_ID_CONFIG_KEY] for model_group in model_groups]
+    if len(model_ids) != len(set(model_ids)):
+        print_error_and_exit(
+            "Each model group id must be unique. Please make sure that "
+            "the model group ids are unique in your endpoints.yml file."
+        )
+
+
+def _validate_model_group_with_multiple_models(
+    model_groups: List[Dict[str, Any]],
+) -> None:
+    # You cannot define multiple models within a model group, when no router is defined.
+    for model_group in model_groups:
+        if (
+            len(model_group[MODELS_CONFIG_KEY]) > 1
+            and ROUTER_CONFIG_KEY not in model_group
+        ):
+            print_error_and_exit(
+                f"You defined multiple models for the model group "
+                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', but no router. "
+                f"If a model group contains "
+                f"multiple models, a router must be defined. Please define a router "
+                f"for the model group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+            )
+
+
+def _validate_model_group_router_setting(
+    model_groups: List[Dict[str, Any]],
+) -> None:
+    # You cannot define multiple models within a model group, when no router is defined.
+    for model_group in model_groups:
+        if ROUTER_CONFIG_KEY not in model_group:
+            continue
+
+        router_config = model_group[ROUTER_CONFIG_KEY]
+        if ROUTER_STRATEGY_CONFIG_KEY in router_config:
+            router_strategy = router_config.get(ROUTER_STRATEGY_CONFIG_KEY)
+            if router_strategy and router_strategy not in VALID_ROUTER_STRATEGIES:
+                print_error_and_exit(
+                    f"The router strategy you defined for the model group "
+                    f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' is not valid. "
+                    f"Valid router strategies are categorized as follows:\n"
+                    f"- Strategies requiring Redis caching: "
+                    f"{', '.join(ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE)}\n"
+                    f"- Strategies not requiring caching: "
+                    f"{', '.join(ROUTER_STRATEGIES_NOT_REQUIRING_CACHE)}"
+                )
+            if (
+                router_strategy in ROUTER_STRATEGIES_REQUIRING_REDIS_CACHE
+                and REDIS_HOST_CONFIG_KEY not in router_config
+            ):
+                structlogger.warning(
+                    "validation.router_strategy.redis_host_not_defined",
+                    event_info=(
+                        f"The router strategy '{router_strategy}' requires a Redis host"
+                        f" to be defined. Without a Redis host, the system defaults to "
+                        f"'in-memory' caching. Please add the '{REDIS_HOST_CONFIG_KEY}'"
+                        f" to the router configuration for the model group "
+                        f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}'."
+                    ),
+                )
+
+
+def _validate_usage_of_environment_variables_in_model_group_config(
+    model_groups: List[Dict[str, Any]],
+) -> None:
+    # Limit the use of ${env_var} in the model_groups config to the following variables:
+    # deployment, api_base, api_key, api_version, aws_region_name
+    allowed_env_vars = {
+        DEPLOYMENT_CONFIG_KEY,
+        API_BASE_CONFIG_KEY,
+        API_KEY,
+        API_VERSION_CONFIG_KEY,
+        AWS_REGION_NAME_CONFIG_KEY,
+    }
+
+    for model_group in model_groups:
+        for model_config in model_group[MODELS_CONFIG_KEY]:
+            for key, value in model_config.items():
+                if isinstance(value, str):
+                    if re.match(r"\${(\w+)}", value) and key not in allowed_env_vars:
+                        print_error_and_exit(
+                            f"You defined '{key}' as environment variable in model "
+                            f"group '{model_group[MODEL_GROUP_ID_CONFIG_KEY]}', "
+                            f"which is not allowed. "
+                            f"You can only use environment variables for the following "
+                            f"keys: {', '.join(allowed_env_vars)}. "
+                            f"Please update your config."
+                        )
+
+
+def _validate_api_key_is_an_environment_variable(
+    model_groups: List[Dict[str, Any]],
+) -> None:
+    # the api key can only be set as an environment variable
+    for model_group in model_groups:
+        for model_config in model_group[MODELS_CONFIG_KEY]:
+            for key, value in model_config.items():
+                if key == API_KEY:
+                    if isinstance(value, str):
+                        if not re.match(r"\${(\w+)}", value):
+                            print_error_and_exit(
+                                f"You defined the '{API_KEY}' in model group "
+                                f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' as a "
+                                f"string. The '{API_KEY}' must be set as an environment"
+                                f" variable. Please update your config."
+                            )
+                    else:
+                        print_error_and_exit(
+                            f"You should define the '{API_KEY}' in model group "
+                            f"'{model_group[MODEL_GROUP_ID_CONFIG_KEY]}' using the "
+                            f"environment variable syntax - ${{ENV_VARIABLE_NAME}}. "
+                            f"Please update your config."
+                        )
+
+
+def validate_model_group_configuration_setup() -> None:
+    """Validates the model group configuration setup in endpoints.yml."""
+    endpoints = AvailableEndpoints.get_instance()
+
+    if endpoints.model_groups is None:
+        return
+
+    _validate_unique_model_group_ids(endpoints.model_groups)
+    _validate_model_group_with_multiple_models(endpoints.model_groups)
+    _validate_usage_of_environment_variables_in_model_group_config(
+        endpoints.model_groups
+    )
+    _validate_api_key_is_an_environment_variable(endpoints.model_groups)
+    _validate_model_group_router_setting(endpoints.model_groups)
+
+
 def validate_command_generator_exclusivity(schema: GraphSchema) -> None:
     """Validate that multiple command generators are not defined at same time."""
     from rasa.dialogue_understanding.generator import (